# HG changeset patch # User lbessard # Date 1193240391 -7200 # Node ID e1f0ebd2d9ecccb065ec780ee46d93d5bcacb367 # Parent 41cb5b80416ec4835aa9b42e10b178d8d8b0c40e Change generate_cc to generate_c diff -r 41cb5b80416e -r e1f0ebd2d9ec .cvsignore --- a/.cvsignore Tue Oct 23 10:35:58 2007 +0200 +++ b/.cvsignore Wed Oct 24 17:39:51 2007 +0200 @@ -5,3 +5,4 @@ *.c *.h iec2cc.exe +iec2c diff -r 41cb5b80416e -r e1f0ebd2d9ec Makefile --- a/Makefile Tue Oct 23 10:35:58 2007 +0200 +++ b/Makefile Wed Oct 24 17:39:51 2007 +0200 @@ -3,25 +3,25 @@ default: all -all: iec2cc iec2iec +all: iec2c iec2iec install: all install -d $(INSTALL_PREDIR)/$(INSTALL_BINDIR)/ install -d $(INSTALL_PREDIR)/$(IECLIBDIR)/ - install iec2cc $(INSTALL_PREDIR)/$(INSTALL_BINDIR)/ + install iec2c $(INSTALL_PREDIR)/$(INSTALL_BINDIR)/ install lib/*.txt $(INSTALL_PREDIR)/$(IECLIBDIR)/ # install iec2iec $(INSTALL_PREDIR)/$(INSTALL_BINDIR)/ uninstall: - rm -f $(INSTALL_PREDIR)/$(INSTALL_BINDIR)/iec2cc + rm -f $(INSTALL_PREDIR)/$(INSTALL_BINDIR)/iec2c rm -f $(INSTALL_PREDIR)/$(INSTALL_BINDIR)/iec2iec for ff in `cd lib; ls *.txt; cd ..` do echo $$ff done # for ff in `cd lib; ls *.txt; cd ..` do rm -f $(INSTALL_PREDIR)/$(IECLIBDIR)/$$ff done clean: - -rm -f iec2iec iec2cc *.o absyntax/*.o Makefile.depend + -rm -f iec2iec iec2c *.o absyntax/*.o Makefile.depend # make something everywhere (ie, in all Makefiles that have that target) find . -depth -mindepth 2 -maxdepth 2 -name Makefile -printf %h\\n | xargs -i make -C{} $@ @@ -30,8 +30,8 @@ LIBS = absyntax/absyntax.o absyntax/visitor.o LIBS += stage1_2/stage1_2.o stage1_2/iec.y.o stage1_2/iec.flex.o -iec2cc: main.o stage4/generate_cc/generate_cc.o stage4/stage4.o $(LIBS) - $(CXX) -o iec2cc main.o stage4/stage4.o stage4/generate_cc/generate_cc.o $(LIBS) +iec2c: main.o stage4/generate_c/generate_c.o stage4/stage4.o $(LIBS) + $(CXX) -o iec2c main.o stage4/stage4.o stage4/generate_c/generate_c.o $(LIBS) iec2iec: main.o stage4/generate_iec/generate_iec.o stage4/stage4.o $(LIBS) diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/.cvsignore --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/.cvsignore Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,2 @@ +Makefile.depend +test_iec_std_lib diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/Makefile --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/Makefile Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,31 @@ +# include the system specific Makefile +include ../../Makefile.$(shell uname) + +default: all + +all: generate_c.o + +clean: + -rm -f *.o */*.o Makefile.depend + +CXXFLAGS += -Wno-unused +CXXFLAGS += -I. -I../* -I../../absyntax + +#how to make things from other directories if they are missing +../% /%: + $(MAKE) -C $(@D) $(@F) + +test_iec_std_lib: test_iec_std_lib.c iec_std_lib.h + gcc -o test_iec_std_lib test_iec_std_lib.c + +test: test_iec_std_lib + +Makefile.depend depend: + $(CXX) -MM -MG -I. *.cc \ + | perl -pe 's/:/ Makefile.depend:/' > Makefile.depend + +include Makefile.depend + + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/decompose_var_instance_name.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/decompose_var_instance_name.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,132 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* Decomposes a variable instance name into its constituents, + * example: + * window.points[1].coordinate.x + * + * will succesfully return + * - window + * - points + * - coordinate + * - x + * on succesive calls to decompose_var_instance_name_c::next_part() + */ +class decompose_var_instance_name_c: null_visitor_c { + + private: + symbol_c *variable_name; + symbol_c *next_variable_name; + symbol_c *current_recursive_variable_name; + symbol_c *previously_returned_variable_name; + + public: + decompose_var_instance_name_c(symbol_c *variable_instance_name) { + variable_name = variable_instance_name; + next_variable_name = NULL; + current_recursive_variable_name = NULL; + previously_returned_variable_name = NULL; + } + + public: + symbol_c *next_part(void) { + /* We must always start from the top! + * See note in the structured_variable_c visitor + * to understand why... + */ + symbol_c *res = (symbol_c *)variable_name->accept(*this); + next_variable_name = current_recursive_variable_name; + + if (previously_returned_variable_name == res) + return NULL; + previously_returned_variable_name = res; + return res; + } + + public: +/*********************/ +/* B 1.4 - Variables */ +/*********************/ + void *visit(symbolic_variable_c *symbol) {return (void *)(symbol->var_name);} + +/********************************************/ +/* B.1.4.1 Directly Represented Variables */ +/********************************************/ + void *visit(direct_variable_c *symbol) {return (void *)symbol;} + +/*************************************/ +/* B.1.4.2 Multi-element Variables */ +/*************************************/ +/* subscripted_variable '[' subscript_list ']' */ +// SYM_REF2(array_variable_c, subscripted_variable, subscript_list) + void *visit(array_variable_c *symbol) { + /* NOTE: the subscripted_variable may itself be a structure!, + * so we must recursevily visit! + */ + return symbol->subscripted_variable->accept(*this); + } + +/* record_variable '.' field_selector */ +/* WARNING: input and/or output variables of function blocks + * may be accessed as fields of a tructured variable! + * Code handling a structured_variable_c must take + * this into account! + */ +//SYM_REF2(structured_variable_c, record_variable, field_selector) + void *visit(structured_variable_c *symbol) { + /* NOTE: The following code will not work, as structured_variable_c + * are grouped on the left, and not on the right! + * + * example: window.origin.x + * will result in + * s1 = structured_variable_c("window, "origin"); + * s2 = structured_variable_c(s1, "x"); + * AND NOT + * s1 = structured_variable_c("origin", "x"); + * s2 = structured_variable_c("window", s1); + * + * as the following code assumes!! + * + current_variable_name = symbol->field_selector; + return symbol->record_variable->accept(*this); + */ + + /* The correct code, is therefore more complex... */ + if (next_variable_name == symbol) { + /* NOTE: field_selector is always an identifier_c, + * so we do not have to recursevily visit it again... + * return (void *)symbol->field_selector->accept(*this); -> NOT REQUIRED!! + */ + return (void *)symbol->field_selector; + } + + current_recursive_variable_name = symbol; + return symbol->record_variable->accept(*this); + } +}; + + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/function_call_iterator.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/function_call_iterator.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,150 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * Function call parameter iterator. + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the IL and ST + * code. + */ + + +//#include /* required for NULL */ +//#include +//#include + +//#include "../../util/symtable.hh" + +//#include "generate_c.hh" + + + + +/* given a function_body_c, iterate through each + * function in/out/inout parameter, returning the name + * of each parameter... + */ +class function_call_iterator_c : public iterator_visitor_c { + private: + symbol_c *start_symbol; + int next_fcall, fcall_count; + //identifier_c *current_fcall_name; + symbol_c *current_fcall_name; + //function_invocation_c *current_finvocation; + symbol_c *current_finvocation; + + public: + /* initialise the iterator object. + * We must be given a reference to the function declaration + * that will be analysed... + */ + function_call_iterator_c(symbol_c *symbol) { + this->start_symbol = symbol; + next_fcall = fcall_count = 0; + current_finvocation = NULL; + current_fcall_name = NULL; + } + + /* Skip to the next function call. After object creation, + * the object references _before_ the first, so + * this function must be called once to get the object to + * reference the first function call... + * + * Returns the function_invocation_c! + */ + //function_invocation_c *next(void) {TRACE("function_call_iterator_c::next(): called "); + symbol_c *next(void) {TRACE("function_call_iterator_c::next(): called "); + fcall_count = 0; + next_fcall++; + current_finvocation = NULL; + current_fcall_name = NULL; + + start_symbol->accept(*this); + return current_finvocation; + } + + /* Returns the name of the currently referenced function invocation */ + identifier_c *fname(void) { + identifier_c *identifier = dynamic_cast(current_fcall_name); + if (identifier == NULL) ERROR; + return identifier; + } + + +/***************************************/ +/* B.3 - Language ST (Structured Text) */ +/***************************************/ +/***********************/ +/* B 3.1 - Expressions */ +/***********************/ + void *visit(function_invocation_c *symbol) { + fcall_count++; + if (next_fcall == fcall_count) { + current_finvocation = symbol; + current_fcall_name = symbol->function_name; + } + return NULL; + } + + + +/****************************************/ +/* B.2 - Language IL (Instruction List) */ +/****************************************/ +/***********************************/ +/* B 2.1 Instructions and Operands */ +/***********************************/ + +/* | function_name [il_operand_list] */ +// SYM_REF2(il_function_call_c, function_name, il_operand_list) + void *visit(il_function_call_c *symbol) { + fcall_count++; + if (next_fcall == fcall_count) { + current_finvocation = symbol; + current_fcall_name = symbol->function_name; + } + return NULL; + } + + + +/* | function_name '(' eol_list [il_param_list] ')' */ +// SYM_REF2(il_formal_funct_call_c, function_name, il_param_list) + void *visit(il_formal_funct_call_c *symbol) { + fcall_count++; + if (next_fcall == fcall_count) { + current_finvocation = symbol; + current_fcall_name = symbol->function_name; + } + return NULL; + } + + +}; + + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/function_call_param_iterator.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/function_call_param_iterator.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,546 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * Function call parameter iterator. + * It will iterate through the formal parameters of a function call + * (i.e. function calls using the foo(, , ...) syntax). + * and/or search through the non-formal parameters of a function call + * (i.e. function calls using the foo( = , = , ...) syntax). + * + * Calls to function blocks and programs are also supported. + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the IL and ST + * code. + */ + + + + + + +//#include /* required for NULL */ +//#include +//#include + +//#include "../../util/symtable.hh" + +//#include "generate_c.hh" + + +#include "../../absyntax/visitor.hh" + + +/* + * Function call parameter iterator. + * It will iterate through the formal parameters of a function call + * (i.e. function calls using the foo(, , ...) syntax). + * and/or search through the non-formal parameters of a function call + * (i.e. function calls using the foo( = , = , ...) syntax). + * + * Calls to function blocks and programs are also supported. + * + * Note that calls to next() will only iterate through formal parameters, + * and calls to search() will only serach through non-formal parameters. + */ + +class function_call_param_iterator_c : public null_visitor_c { + private: + /* a pointer to the function call + * (or function block or program call!) + */ + symbol_c *f_call; + int next_param, param_count; + identifier_c *search_param_name; + + /* Which operation of the class was called... + * Search a parameter, or iterate to the next parameter. + */ + typedef enum {iterate_op, search_op} operation_t; + operation_t current_operation; + + private: + void *search_list(list_c *list) { + switch (current_operation) { + case iterate_op: + for(int i = 0; i < list->n; i++) { + void *res = list->elements[i]->accept(*this); + if (NULL != res) { + /* It went through the handle_parameter_assignment() function, + * and is therefore a parameter assignment ( = ), + * and not a simple expression (). + */ + /* we do nothing... */ + } else { + param_count++; + if (param_count == next_param) { + return list->elements[i]; + } + } + } + return NULL; + break; + + case search_op: + for(int i = 0; i < list->n; i++) { + void *res = list->elements[i]->accept(*this); + if (res != NULL) + return res; + } + return NULL; + break; + } /* switch */ + return NULL; + } + + + + void *handle_parameter_assignment(symbol_c *variable_name, symbol_c *expression) { + switch (current_operation) { + case iterate_op: + /* UGLY HACK -> this will be detected in the search_list() function */ + return (void *)this; /* anything, as long as it is not NULL!! */ + break; + + case search_op: + identifier_c *variable_name2 = dynamic_cast(variable_name); + if (variable_name2 == NULL) ERROR; + if (strcasecmp(search_param_name->value, variable_name2->value) == 0) + /* FOUND! This is the same parameter!! */ + return (void *)expression; + return NULL; + break; + } + + ERROR; + return NULL; + } + + + + public: + /* start off at the first parameter once again... */ + void reset(void) { + next_param = param_count = 0; + } + + /* initialise the iterator object. + * We must be given a reference to the function/program/function block call + * that will be analysed... + */ + function_call_param_iterator_c(symbol_c *f_call) { + /* It is expected that f_call will reference one of the following: + * program_configuration_c + * function_invocation_c + * fb_invocation_c + * il_function_call_c + * il_formal_funct_call_c + * ... (have I missed any?) + */ + this->f_call = f_call; + search_param_name = NULL; + reset(); + } + + /* Skip to the next parameter. After object creation, + * the object references on parameter _before_ the first, so + * this function must be called once to get the object to + * reference the first parameter... + * + * Returns whatever is being passed to the parameter! + */ + symbol_c *next(void) { + param_count = 0; + next_param++; + current_operation = function_call_param_iterator_c::iterate_op; + void *res = f_call->accept(*this); + return (symbol_c *)res; + } + + /* Search for the value passed to the parameter named ... */ + symbol_c *search(symbol_c *param_name) { + if (NULL == param_name) ERROR; + search_param_name = dynamic_cast(param_name); + if (NULL == search_param_name) ERROR; + current_operation = function_call_param_iterator_c::search_op; + void *res = f_call->accept(*this); + return (symbol_c *)res; + } + + + + + private: +/********************************/ +/* B 1.7 Configuration elements */ +/********************************/ + +/* +CONFIGURATION configuration_name + optional_global_var_declarations + (resource_declaration_list | single_resource_declaration) + optional_access_declarations + optional_instance_specific_initializations +END_CONFIGURATION +*/ +/* +SYM_REF6(configuration_declaration_c, configuration_name, global_var_declarations, resource_declarations, access_declarations, instance_specific_initializations, unused) +*/ + +/* helper symbol for configuration_declaration */ +/* +SYM_LIST(resource_declaration_list_c) +*/ + +/* +RESOURCE resource_name ON resource_type_name + optional_global_var_declarations + single_resource_declaration +END_RESOURCE +*/ +/* +SYM_REF4(resource_declaration_c, resource_name, resource_type_name, global_var_declarations, resource_declaration) +*/ + +/* task_configuration_list program_configuration_list */ +/* +SYM_REF2(single_resource_declaration_c, task_configuration_list, program_configuration_list) +*/ + +/* helper symbol for single_resource_declaration */ +/* +SYM_LIST(task_configuration_list_c) +*/ + +/* helper symbol for single_resource_declaration */ +/* +SYM_LIST(program_configuration_list_c) +*/ + +/* helper symbol for + * - access_path + * - instance_specific_init + */ +/* +SYM_LIST(any_fb_name_list_c) +*/ + +/* [resource_name '.'] global_var_name ['.' structure_element_name] */ +/* +SYM_REF4(global_var_reference_c, resource_name, global_var_name, structure_element_name, unused) +*/ + +/* prev_declared_program_name '.' symbolic_variable */ +/* +SYM_REF2(program_output_reference_c, program_name, symbolic_variable) +*/ + +/* TASK task_name task_initialization */ +/* +SYM_REF2(task_configuration_c, task_name, task_initialization) +*/ + +/* '(' [SINGLE ASSIGN data_source ','] [INTERVAL ASSIGN data_source ','] PRIORITY ASSIGN integer ')' */ +/* +SYM_REF4(task_initialization_c, single_data_source, interval_data_source, priority_data_source, unused) +*/ + +/* PROGRAM [RETAIN | NON_RETAIN] program_name [WITH task_name] ':' program_type_name ['(' prog_conf_elements ')'] */ +// SYM_REF6(program_configuration_c, retain_option, program_name, task_name, program_type_name, prog_conf_elements, unused) + void *visit(program_configuration_c *symbol) { + TRACE("program_configuration_c"); + return symbol->prog_conf_elements->accept(*this); + } + +/* prog_conf_elements ',' prog_conf_element */ +// SYM_LIST(prog_conf_elements_c) + void *visit(prog_conf_elements_c *symbol) { + TRACE("prog_conf_elements_c"); + return search_list(symbol); + } + +/* fb_name WITH task_name */ +/* +SYM_REF2(fb_task_c, fb_name, task_name) +*/ + +/* any_symbolic_variable ASSIGN prog_data_source */ +// SYM_REF2(prog_cnxn_assign_c, symbolic_variable, prog_data_source) + void *visit(prog_cnxn_assign_c *symbol) { + TRACE("prog_cnxn_assign_c"); + + /* NOTE: symbolic_variable may be something other than a symbolic_variable_c, but I (Mario) + * do not understand the semantics that should be implmeneted if it is not a + * symbolic_variable, so for the moment we simply give up! + */ + symbolic_variable_c *symb_var = dynamic_cast(symbol->symbolic_variable); + if (NULL == symb_var) + ERROR; + + return handle_parameter_assignment(symb_var->var_name, symbol->prog_data_source); + } + +/* any_symbolic_variable SENDTO data_sink */ +// SYM_REF2(prog_cnxn_sendto_c, symbolic_variable, prog_data_source) + void *visit(prog_cnxn_sendto_c *symbol) { + TRACE("prog_cnxn_sendto_c"); + + /* NOTE: symbolic_variable may be something other than a symbolic_variable_c, but I (Mario) + * do not understand the semantics that should be implmeneted if it is not a + * symbolic_variable, so for the moment we simply give up! + */ + symbolic_variable_c *symb_var = dynamic_cast(symbol->symbolic_variable); + if (NULL == symb_var) + ERROR; + + return handle_parameter_assignment(symb_var->var_name, symbol->data_sink); + } + +/* VAR_CONFIG instance_specific_init_list END_VAR */ +/* +SYM_REF2(instance_specific_initializations_c, instance_specific_init_list, unused) +*/ + +/* helper symbol for instance_specific_initializations */ +/* +SYM_LIST(instance_specific_init_list_c) +*/ + +/* resource_name '.' program_name '.' {fb_name '.'} + ((variable_name [location] ':' located_var_spec_init) | (fb_name ':' fb_initialization)) +*/ +/* +SYM_REF6(instance_specific_init_c, resource_name, program_name, any_fb_name_list, variable_name, location, initialization) +*/ + +/* helper symbol for instance_specific_init */ +/* function_block_type_name ':=' structure_initialization */ +/* +SYM_REF2(fb_initialization_c, function_block_type_name, structure_initialization) +*/ + + + + + + +/****************************************/ +/* B.2 - Language IL (Instruction List) */ +/****************************************/ +/***********************************/ +/* B 2.1 Instructions and Operands */ +/***********************************/ + +/* | function_name [il_operand_list] */ +// SYM_REF2(il_function_call_c, function_name, il_operand_list) + void *visit(il_function_call_c *symbol) { + TRACE("il_function_call_c"); + if (NULL != symbol->il_operand_list) + return symbol->il_operand_list->accept(*this); + return NULL; + } + + +/* | function_name '(' eol_list [il_param_list] ')' */ +// SYM_REF2(il_formal_funct_call_c, function_name, il_param_list) + void *visit(il_formal_funct_call_c *symbol) { + TRACE("il_formal_funct_call_c"); + if (NULL != symbol->il_param_list) + return symbol->il_param_list->accept(*this); + return NULL; + } + + +/* il_call_operator prev_declared_fb_name + * | il_call_operator prev_declared_fb_name '(' ')' + * | il_call_operator prev_declared_fb_name '(' eol_list ')' + * | il_call_operator prev_declared_fb_name '(' il_operand_list ')' + * | il_call_operator prev_declared_fb_name '(' eol_list il_param_list ')' + */ +// SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list) + void *visit(il_fb_call_c *symbol) { + TRACE("il_fb_call_c"); + /* the following should never occur. In reality the syntax parser + * will guarantee that they never occur, but it makes it easier to + * understand the remaining code :-) + */ + //if ((NULL == symbol->il_operand_list) && (NULL == symbol->il_param_list)) ERROR; + //if ((NULL != symbol->il_operand_list) && (NULL != symbol->il_param_list)) ERROR; + + if (NULL != symbol->il_operand_list) + return symbol->il_operand_list->accept(*this); + if (NULL != symbol->il_param_list) + return symbol->il_param_list->accept(*this); + return NULL; + } + + + +/* | il_operand_list ',' il_operand */ +// SYM_LIST(il_operand_list_c) + void *visit(il_operand_list_c *symbol) { + TRACE("il_operand_list_c"); + return search_list(symbol); + } + + +/* | il_initial_param_list il_param_instruction */ +// SYM_LIST(il_param_list_c) + void *visit(il_param_list_c *symbol) { + TRACE("il_param_list_c"); + return search_list(symbol); + } + +/* il_assign_operator il_operand + * | il_assign_operator '(' eol_list simple_instr_list ')' + */ +// SYM_REF4(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list, unused) + void *visit(il_param_assignment_c *symbol) { + TRACE("il_param_assignment_c"); + + // TODO : We do not yet handle a instruction list passed as parameter !!! + // since we do not yet support it, it is best to simply stop than to fail silently... + if (NULL != symbol->simple_instr_list) ERROR; + + return handle_parameter_assignment(symbol->il_assign_operator, symbol->il_operand); + } + +/* il_assign_out_operator variable */ +// SYM_REF2(il_param_out_assignment_c, il_assign_out_operator, variable); + void *visit(il_param_out_assignment_c *symbol) { + TRACE("il_param_out_assignment_c"); + return handle_parameter_assignment((symbol_c *)symbol->il_assign_out_operator->accept(*this), symbol->variable); + } + + +/*******************/ +/* B 2.2 Operators */ +/*******************/ +/*| [NOT] any_identifier SENDTO */ +// SYM_REF2(il_assign_out_operator_c, option, variable_name) + void *visit(il_assign_out_operator_c *symbol) { + TRACE("il_assign_out_operator_c"); + + // TODO : Handle not_param !!! + // we do not yet support it, so it is best to simply stop than to fail silently... + if (NULL != symbol->option) ERROR; + + return (void *)symbol->variable_name; + } + + + + +/***************************************/ +/* B.3 - Language ST (Structured Text) */ +/***************************************/ +/***********************/ +/* B 3.1 - Expressions */ +/***********************/ + +/* +SYM_REF2(function_invocation_c, function_name, parameter_assignment_list) +*/ + void *visit(function_invocation_c *symbol) { + TRACE("function_invocation_c"); + if ((symbol_c *)symbol == f_call && symbol->parameter_assignment_list != NULL) + return symbol->parameter_assignment_list->accept(*this); + else + return NULL; + } + + + + +/********************/ +/* B 3.2 Statements */ +/********************/ + +/*********************************/ +/* B 3.2.1 Assignment Statements */ +/*********************************/ +/* +SYM_REF2(assignment_statement_c, l_exp, r_exp) +*/ + +/*****************************************/ +/* B 3.2.2 Subprogram Control Statements */ +/*****************************************/ +/* RETURN */ +// SYM_REF0(return_statement_c) + + +/* fb_name '(' [param_assignment_list] ')' */ +/* param_assignment_list -> may be NULL ! */ +// SYM_REF2(fb_invocation_c, fb_name, param_assignment_list) + void *visit(fb_invocation_c *symbol) { + TRACE("fb_invocation_c"); + if (symbol->param_assignment_list != NULL) + return symbol->param_assignment_list->accept(*this); + else + return NULL; + } + +/* helper symbol for fb_invocation */ +/* param_assignment_list ',' param_assignment */ +// SYM_LIST(param_assignment_list_c) + void *visit(param_assignment_list_c *symbol) { + TRACE("param_assignment_list_c"); + return search_list(symbol); + } + +/* variable_name ASSIGN expression */ +// SYM_REF2(input_variable_param_assignment_c, variable_name, expression) + void *visit(input_variable_param_assignment_c *symbol) { + TRACE("input_variable_param_assignment_c"); + return handle_parameter_assignment(symbol->variable_name, symbol->expression); + } + +/* [NOT] variable_name '=>' variable */ +// SYM_REF4(output_variable_param_assignment_c, not_param, variable_name, variable, unused) + void *visit(output_variable_param_assignment_c *symbol) { + TRACE("output_variable_param_assignment_c"); + // TODO : Handle not_param !!! + if (NULL != symbol->not_param) ERROR; // we do not yet support it, so it is best to simply stop than to fail silently... + + return handle_parameter_assignment(symbol->variable_name, symbol->variable); + } + +/* helper CLASS for output_variable_param_assignment */ +// SYM_REF0(not_paramassign_c) +// TODO... ??? + + + + + +}; + + + + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/function_param_iterator.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/function_param_iterator.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,426 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * Function parameter iterator. + * Iterate through the in/out parameters of a function declaration. + * Function blocks are also suported. + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the IL and ST + * code. + */ + + + + + + +//#include /* required for NULL */ +//#include +//#include + +//#include "../../util/symtable.hh" + +//#include "generate_c.hh" + + +#include "../../absyntax/visitor.hh" + + +/* given a function_declaration_c, iterate through each + * function in/out/inout parameter, returning the name + * of each parameter...function_param_iterator_c + */ +class function_param_iterator_c : public null_visitor_c { + public: + /* A type to specify the type of parameter. + * VAR_INPUT => direction_in + * VAR_OUTPUT => direction_out + * VAR_IN_OUT => direction_inout + * VAR_EXTERNAL => direction_extref + * + * Note that VAR_EXTERNAL declares variables that are in reality references + * to global variables. This is used only inside programs! + * These references to external variables must be correctly initialised to refer + * to the correct global variable. Note that the user may define which variable is to be + * referenced in a CONFIGURATION, and that different instantiations of a program + * may have the same external variable reference diffenrent global variables! + * The references must therefore be correctly initialised when the program instance + * is created. This may be done by the PROGRAM class constructor since the ST and IL + * languages do not allow the VAR_EXTERNAL reference to change at runtime + * for a specific instance. + * + * We therefore need to call a PROGRAM class constructor with the variables + * that should be refernced by the VAR_EXTERNAL variables. The direction_extref will + * be used to identify these parameters! + */ + typedef enum {direction_in, direction_out, direction_inout, direction_extref} param_direction_t ; + + + private: + /* a pointer to the function_block_declaration_c + * or function_declaration_c currently being analysed. + */ + symbol_c *f_decl; + int next_param, param_count; + identifier_c *current_param_name; + symbol_c *current_param_type; + symbol_c *current_param_default_value; + param_direction_t current_param_direction; + + private: + void* handle_param_list(list_c *list) { + if (next_param <= param_count + list->n) + return list->elements[next_param - param_count - 1]; + + /* the desired param is not on this list... */ + param_count += list->n; + return NULL; + } + + void* handle_single_param(symbol_c *var_name) { + param_count++; + if (next_param == param_count) + return var_name; + + /* not yet the desired param... */ + return NULL; + } + + void* iterate_list(list_c *list) { + void *res; + for (int i = 0; i < list->n; i++) { + res = list->elements[i]->accept(*this); + if (res != NULL) + return res; + } + return NULL; + } + + + public: + /* start off at the first parameter once again... */ + void reset(void) { + next_param = param_count = 0; + current_param_name = NULL; + current_param_type = current_param_default_value = NULL; + } + + /* initialise the iterator object. + * We must be given a reference to the function declaration + * that will be analysed... + */ + function_param_iterator_c(function_declaration_c *f_decl) { + this->f_decl = f_decl; + reset(); + } + + /* initialise the iterator object. + * We must be given a reference to the function block declaration + * that will be analysed... + */ + function_param_iterator_c(function_block_declaration_c *fb_decl) { + this->f_decl = fb_decl; + reset(); + } + + /* initialise the iterator object. + * We must be given a reference to the program declaration + * that will be analysed... + */ + function_param_iterator_c(program_declaration_c *p_decl) { + this->f_decl = p_decl; + reset(); + } + + /* Skip to the next parameter. After object creation, + * the object references on parameter _before_ the first, so + * this function must be called once to get the object to + * reference the first parameter... + * + * Returns the parameter's name! + */ + identifier_c *next(void) { + void *res; + param_count = 0; + next_param++; + res = f_decl->accept(*this); + if (res == NULL) + return NULL; + + symbol_c *sym = (symbol_c *)res; + identifier_c *identifier = dynamic_cast(sym); + if (identifier == NULL) + ERROR; + + current_param_name = identifier; + return current_param_name; + } + + /* Returns the currently referenced parameter's default value, + * or NULL if none is specified in the function declrataion itself. + */ + symbol_c *default_value(void) { + return current_param_default_value; + } + + /* Returns the currently referenced parameter's type name. */ + symbol_c *param_type(void) { + return current_param_type; + } + + /* Returns the currently referenced parameter's data passing direction. + * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT + */ + param_direction_t param_direction(void) { + return current_param_direction; + } + +/******************************************/ +/* B 1.4.3 - Declaration & Initialisation */ +/******************************************/ + void *visit(input_declarations_c *symbol) { + TRACE("input_declarations_c"); + current_param_direction = direction_in; + return symbol->input_declaration_list->accept(*this); + } + void *visit(input_declaration_list_c *symbol) {TRACE("input_declaration_list_c"); return iterate_list(symbol);} + void *visit(edge_declaration_c *symbol) {TRACE("edge_declaration_c"); return symbol->var1_list->accept(*this);} + +#if 0 +/* var1_list ':' array_spec_init */ +SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init) + +/* var1_list ':' initialized_structure */ +SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure) + +/* name_list ':' function_block_type_name ASSIGN structure_initialization */ +/* structure_initialization -> may be NULL ! */ +SYM_REF4(fb_name_decl_c, fb_name_list, function_block_type_name, structure_initialization, unused) + +/* name_list ',' fb_name */ +SYM_LIST(fb_name_list_c) +#endif + + void *visit(output_declarations_c *symbol) { + TRACE("output_declarations_c"); + current_param_direction = direction_out; + return symbol->var_init_decl_list->accept(*this); + } + void *visit(input_output_declarations_c *symbol) { + TRACE("input_output_declarations_c"); + current_param_direction = direction_inout; + return symbol->var_declaration_list->accept(*this); + } + void *visit(var_declaration_list_c *symbol) {TRACE("var_declaration_list_c"); return iterate_list(symbol);} + +#if 0 +/* var1_list ':' array_specification */ +SYM_REF2(array_var_declaration_c, var1_list, array_specification) + +/* var1_list ':' structure_type_name */ +SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name) +#endif + +/* VAR [CONSTANT] var_init_decl_list END_VAR */ + void *visit(var_declarations_c *symbol) {TRACE("var_declarations_c"); return NULL;} + +#if 0 +/* VAR RETAIN var_init_decl_list END_VAR */ +SYM_REF2(retentive_var_declarations_c, var_init_decl_list, unused) + +/* VAR [CONSTANT|RETAIN|NON_RETAIN] located_var_decl_list END_VAR */ +/* option -> may be NULL ! */ +SYM_REF2(located_var_declarations_c, option, located_var_decl_list) + +/* helper symbol for located_var_declarations */ +/* located_var_decl_list located_var_decl ';' */ +SYM_LIST(located_var_decl_list_c) + +/* [variable_name] location ':' located_var_spec_init */ +/* variable_name -> may be NULL ! */ +SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused) +#endif + +/*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */ +/* option -> may be NULL ! */ +// SYM_REF2(external_var_declarations_c, option, external_declaration_list) + void *visit(external_var_declarations_c *symbol) { + TRACE("external_var_declarations_c"); + current_param_direction = direction_extref; + return symbol->external_declaration_list->accept(*this); + } + +/* helper symbol for external_var_declarations */ +/*| external_declaration_list external_declaration';' */ +// SYM_LIST(external_declaration_list_c) + void *visit(external_declaration_list_c *symbol) {TRACE("external_declaration_list_c"); return iterate_list(symbol);} + +/* global_var_name ':' (simple_specification|subrange_specification|enumerated_specification|array_specification|prev_declared_structure_type_name|function_block_type_name */ +//SYM_REF2(external_declaration_c, global_var_name, specification) + void *visit(external_declaration_c *symbol) { + TRACE("external_declaration_c"); + /* It is OK to store these values in the current_param_XXX + * variables, because if the desired parameter is not in the + * variable list we will be analysing, the current_param_XXXX + * variables will get overwritten when we visit the next + * var1_init_decl_c list! + */ + current_param_default_value = spec_init_sperator_c::get_init(symbol->specification); + current_param_type = spec_init_sperator_c::get_spec(symbol->specification); + + return handle_single_param(symbol->global_var_name); + } + + +#if 0 +/*| VAR_GLOBAL [CONSTANT|RETAIN] global_var_decl_list END_VAR */ +/* option -> may be NULL ! */ +SYM_REF2(global_var_declarations_c, option, global_var_decl_list) + +/* helper symbol for global_var_declarations */ +/*| global_var_decl_list global_var_decl ';' */ +SYM_LIST(global_var_decl_list_c) + +/*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */ +/* type_specification ->may be NULL ! */ +SYM_REF2(global_var_decl_c, global_var_spec, type_specification) + +/*| global_var_name location */ +SYM_REF2(global_var_spec_c, global_var_name, location) + +/* AT direct_variable */ +SYM_REF2(location_c, direct_variable, unused) + +/*| global_var_list ',' global_var_name */ +SYM_LIST(global_var_list_c) + +/* var1_list ':' single_byte_string_spec */ +SYM_REF2(single_byte_string_var_declaration_c, var1_list, single_byte_string_spec) + +/* STRING ['[' integer ']'] [ASSIGN single_byte_character_string] */ +/* integer ->may be NULL ! */ +/* single_byte_character_string ->may be NULL ! */ +SYM_REF2(single_byte_string_spec_c, integer, single_byte_character_string) + +/* var1_list ':' double_byte_string_spec */ +SYM_REF2(double_byte_string_var_declaration_c, var1_list, double_byte_string_spec) + +/* WSTRING ['[' integer ']'] [ASSIGN double_byte_character_string] */ +/* integer ->may be NULL ! */ +/* double_byte_character_string ->may be NULL ! */ +SYM_REF2(double_byte_string_spec_c, integer, double_byte_character_string) + +/*| VAR [RETAIN|NON_RETAIN] incompl_located_var_decl_list END_VAR */ +/* option ->may be NULL ! */ +SYM_REF2(incompl_located_var_declarations_c, option, incompl_located_var_decl_list) + +/* helper symbol for incompl_located_var_declarations */ +/*| incompl_located_var_decl_list incompl_located_var_decl ';' */ +SYM_LIST(incompl_located_var_decl_list_c) + +/* variable_name incompl_location ':' var_spec */ +SYM_REF4(incompl_located_var_decl_c, variable_name, incompl_location, var_spec, unused) + +/* AT incompl_location_token */ +SYM_TOKEN(incompl_location_c) +#endif + + + void *visit(var1_init_decl_c *symbol) { + TRACE("var1_init_decl_c"); + /* It is OK to store these values in the current_param_XXX + * variables, because if the desired parameter is not in the + * variable list we will be analysing, the current_param_XXXX + * variables will get overwritten when we visit the next + * var1_init_decl_c list! + */ + current_param_default_value = spec_init_sperator_c::get_init(symbol->spec_init); + current_param_type = spec_init_sperator_c::get_spec(symbol->spec_init); + + return symbol->var1_list->accept(*this); + } + + + + void *visit(var1_list_c *symbol) { + TRACE("var1_list_c"); + return handle_param_list(symbol); + } + + void *visit(var_init_decl_list_c *symbol) {TRACE("var_init_decl_list_c"); return iterate_list(symbol);} + + +/***********************/ +/* B 1.5.1 - Functions */ +/***********************/ + void *visit(function_declaration_c *symbol) {TRACE("function_declaration_c"); return symbol->var_declarations_list->accept(*this);} + /* intermediate helper symbol for function_declaration */ + void *visit(var_declarations_list_c *symbol) {TRACE("var_declarations_list_c"); return iterate_list(symbol);} + void *visit(function_var_decls_c *symbol) {TRACE("function_var_decls_c"); /* ignore */ return NULL;} + + +/*****************************/ +/* B 1.5.2 - Function Blocks */ +/*****************************/ +/* FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */ + void *visit(function_block_declaration_c *symbol) {TRACE("function_block_declaration_c"); return symbol->var_declarations->accept(*this);} + +/* intermediate helper symbol for function_declaration */ +/* { io_var_declarations | other_var_declarations } */ +/* + * NOTE: we re-use the var_declarations_list_c + */ + +/* VAR_TEMP temp_var_decl_list END_VAR */ + void *visit(temp_var_decls_c *symbol) {TRACE("temp_var_decls_c"); /* ignore */ return NULL;} + void *visit(temp_var_decls_list_c *symbol) {TRACE("temp_var_decls_list_c"); /* ignore */ return NULL;} + +/* VAR NON_RETAIN var_init_decl_list END_VAR */ + void *visit(non_retentive_var_decls_c *symbol) {TRACE("non_retentive_var_decls_c"); /* ignore */ return NULL;} + + +/**********************/ +/* B 1.5.3 - Programs */ +/**********************/ +/* PROGRAM program_type_name program_var_declarations_list function_block_body END_PROGRAM */ +// SYM_REF4(program_declaration_c, program_type_name, var_declarations, function_block_body, unused) + void *visit(program_declaration_c *symbol) {TRACE("program_declaration_c"); return symbol->var_declarations->accept(*this);} + +/* intermediate helper symbol for program_declaration_c */ +/* { io_var_declarations | other_var_declarations } */ +/* + * NOTE: we re-use the var_declarations_list_c + */ + +}; + + + + + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/function_type_decl.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/function_type_decl.h Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,453 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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 lib + * generated code, do not edit by hand + */ +typedef enum { + function_bool_to_sint, + function_bool_to_int, + function_bool_to_dint, + function_bool_to_lint, + function_bool_to_usint, + function_bool_to_uint, + function_bool_to_udint, + function_bool_to_ulint, + function_bool_to_real, + function_bool_to_lreal, + function_bool_to_time, + function_bool_to_date, + function_bool_to_tod, + function_bool_to_dt, + function_bool_to_string, + function_bool_to_byte, + function_bool_to_word, + function_bool_to_dword, + function_bool_to_lword, + function_sint_to_bool, + function_sint_to_int, + function_sint_to_dint, + function_sint_to_lint, + function_sint_to_usint, + function_sint_to_uint, + function_sint_to_udint, + function_sint_to_ulint, + function_sint_to_real, + function_sint_to_lreal, + function_sint_to_time, + function_sint_to_date, + function_sint_to_tod, + function_sint_to_dt, + function_sint_to_string, + function_sint_to_byte, + function_sint_to_word, + function_sint_to_dword, + function_sint_to_lword, + function_int_to_bool, + function_int_to_sint, + function_int_to_dint, + function_int_to_lint, + function_int_to_usint, + function_int_to_uint, + function_int_to_udint, + function_int_to_ulint, + function_int_to_real, + function_int_to_lreal, + function_int_to_time, + function_int_to_date, + function_int_to_tod, + function_int_to_dt, + function_int_to_string, + function_int_to_byte, + function_int_to_word, + function_int_to_dword, + function_int_to_lword, + function_dint_to_bool, + function_dint_to_sint, + function_dint_to_int, + function_dint_to_lint, + function_dint_to_usint, + function_dint_to_uint, + function_dint_to_udint, + function_dint_to_ulint, + function_dint_to_real, + function_dint_to_lreal, + function_dint_to_time, + function_dint_to_date, + function_dint_to_tod, + function_dint_to_dt, + function_dint_to_string, + function_dint_to_byte, + function_dint_to_word, + function_dint_to_dword, + function_dint_to_lword, + function_lint_to_bool, + function_lint_to_sint, + function_lint_to_int, + function_lint_to_dint, + function_lint_to_usint, + function_lint_to_uint, + function_lint_to_udint, + function_lint_to_ulint, + function_lint_to_real, + function_lint_to_lreal, + function_lint_to_time, + function_lint_to_date, + function_lint_to_tod, + function_lint_to_dt, + function_lint_to_string, + function_lint_to_byte, + function_lint_to_word, + function_lint_to_dword, + function_lint_to_lword, + function_usint_to_bool, + function_usint_to_sint, + function_usint_to_int, + function_usint_to_dint, + function_usint_to_lint, + function_usint_to_uint, + function_usint_to_udint, + function_usint_to_ulint, + function_usint_to_real, + function_usint_to_lreal, + function_usint_to_time, + function_usint_to_date, + function_usint_to_tod, + function_usint_to_dt, + function_usint_to_string, + function_usint_to_byte, + function_usint_to_word, + function_usint_to_dword, + function_usint_to_lword, + function_uint_to_bool, + function_uint_to_sint, + function_uint_to_int, + function_uint_to_dint, + function_uint_to_lint, + function_uint_to_usint, + function_uint_to_udint, + function_uint_to_ulint, + function_uint_to_real, + function_uint_to_lreal, + function_uint_to_time, + function_uint_to_date, + function_uint_to_tod, + function_uint_to_dt, + function_uint_to_string, + function_uint_to_byte, + function_uint_to_word, + function_uint_to_dword, + function_uint_to_lword, + function_udint_to_bool, + function_udint_to_sint, + function_udint_to_int, + function_udint_to_dint, + function_udint_to_lint, + function_udint_to_usint, + function_udint_to_uint, + function_udint_to_ulint, + function_udint_to_real, + function_udint_to_lreal, + function_udint_to_time, + function_udint_to_date, + function_udint_to_tod, + function_udint_to_dt, + function_udint_to_string, + function_udint_to_byte, + function_udint_to_word, + function_udint_to_dword, + function_udint_to_lword, + function_ulint_to_bool, + function_ulint_to_sint, + function_ulint_to_int, + function_ulint_to_dint, + function_ulint_to_lint, + function_ulint_to_usint, + function_ulint_to_uint, + function_ulint_to_udint, + function_ulint_to_real, + function_ulint_to_lreal, + function_ulint_to_time, + function_ulint_to_date, + function_ulint_to_tod, + function_ulint_to_dt, + function_ulint_to_string, + function_ulint_to_byte, + function_ulint_to_word, + function_ulint_to_dword, + function_ulint_to_lword, + function_real_to_bool, + function_real_to_sint, + function_real_to_int, + function_real_to_dint, + function_real_to_lint, + function_real_to_usint, + function_real_to_uint, + function_real_to_udint, + function_real_to_ulint, + function_real_to_lreal, + function_real_to_time, + function_real_to_date, + function_real_to_tod, + function_real_to_dt, + function_real_to_string, + function_real_to_byte, + function_real_to_word, + function_real_to_dword, + function_real_to_lword, + function_lreal_to_bool, + function_lreal_to_sint, + function_lreal_to_int, + function_lreal_to_dint, + function_lreal_to_lint, + function_lreal_to_usint, + function_lreal_to_uint, + function_lreal_to_udint, + function_lreal_to_ulint, + function_lreal_to_real, + function_lreal_to_time, + function_lreal_to_date, + function_lreal_to_tod, + function_lreal_to_dt, + function_lreal_to_string, + function_lreal_to_byte, + function_lreal_to_word, + function_lreal_to_dword, + function_lreal_to_lword, + function_time_to_sint, + function_time_to_int, + function_time_to_dint, + function_time_to_lint, + function_time_to_usint, + function_time_to_uint, + function_time_to_udint, + function_time_to_ulint, + function_time_to_real, + function_time_to_lreal, + function_time_to_string, + function_time_to_byte, + function_time_to_word, + function_time_to_dword, + function_time_to_lword, + function_date_to_sint, + function_date_to_int, + function_date_to_dint, + function_date_to_lint, + function_date_to_usint, + function_date_to_uint, + function_date_to_udint, + function_date_to_ulint, + function_date_to_real, + function_date_to_lreal, + function_date_to_string, + function_date_to_byte, + function_date_to_word, + function_date_to_dword, + function_date_to_lword, + function_tod_to_sint, + function_tod_to_int, + function_tod_to_dint, + function_tod_to_lint, + function_tod_to_usint, + function_tod_to_uint, + function_tod_to_udint, + function_tod_to_ulint, + function_tod_to_real, + function_tod_to_lreal, + function_tod_to_string, + function_tod_to_byte, + function_tod_to_word, + function_tod_to_dword, + function_tod_to_lword, + function_dt_to_sint, + function_dt_to_int, + function_dt_to_dint, + function_dt_to_lint, + function_dt_to_usint, + function_dt_to_uint, + function_dt_to_udint, + function_dt_to_ulint, + function_dt_to_real, + function_dt_to_lreal, + function_dt_to_string, + function_dt_to_byte, + function_dt_to_word, + function_dt_to_dword, + function_dt_to_lword, + function_string_to_bool, + function_string_to_sint, + function_string_to_int, + function_string_to_dint, + function_string_to_lint, + function_string_to_usint, + function_string_to_uint, + function_string_to_udint, + function_string_to_ulint, + function_string_to_real, + function_string_to_lreal, + function_string_to_time, + function_string_to_date, + function_string_to_tod, + function_string_to_dt, + function_string_to_byte, + function_string_to_word, + function_string_to_dword, + function_string_to_lword, + function_byte_to_bool, + function_byte_to_sint, + function_byte_to_int, + function_byte_to_dint, + function_byte_to_lint, + function_byte_to_usint, + function_byte_to_uint, + function_byte_to_udint, + function_byte_to_ulint, + function_byte_to_real, + function_byte_to_lreal, + function_byte_to_time, + function_byte_to_date, + function_byte_to_tod, + function_byte_to_dt, + function_byte_to_string, + function_byte_to_word, + function_byte_to_dword, + function_byte_to_lword, + function_word_to_bool, + function_word_to_sint, + function_word_to_int, + function_word_to_dint, + function_word_to_lint, + function_word_to_usint, + function_word_to_uint, + function_word_to_udint, + function_word_to_ulint, + function_word_to_real, + function_word_to_lreal, + function_word_to_time, + function_word_to_date, + function_word_to_tod, + function_word_to_dt, + function_word_to_string, + function_word_to_byte, + function_word_to_dword, + function_word_to_lword, + function_dword_to_bool, + function_dword_to_sint, + function_dword_to_int, + function_dword_to_dint, + function_dword_to_lint, + function_dword_to_usint, + function_dword_to_uint, + function_dword_to_udint, + function_dword_to_ulint, + function_dword_to_real, + function_dword_to_lreal, + function_dword_to_time, + function_dword_to_date, + function_dword_to_tod, + function_dword_to_dt, + function_dword_to_string, + function_dword_to_byte, + function_dword_to_word, + function_dword_to_lword, + function_lword_to_bool, + function_lword_to_sint, + function_lword_to_int, + function_lword_to_dint, + function_lword_to_lint, + function_lword_to_usint, + function_lword_to_uint, + function_lword_to_udint, + function_lword_to_ulint, + function_lword_to_real, + function_lword_to_lreal, + function_lword_to_time, + function_lword_to_date, + function_lword_to_tod, + function_lword_to_dt, + function_lword_to_string, + function_lword_to_byte, + function_lword_to_word, + function_lword_to_dword, + function_trunc, + function_bcd_to_usint, + function_bcd_to_uint, + function_bcd_to_udint, + function_bcd_to_ulint, + function_usint_to_bcd, + function_uint_to_bcd, + function_udint_to_bcd, + function_ulint_to_bcd, + function_date_and_time_to_time_of_day, + function_date_and_time_to_date, + function_abs, + function_sqrt, + function_ln, + function_log, + function_exp, + function_sin, + function_cos, + function_tan, + function_asin, + function_acos, + function_atan, + function_add, + function_mul, + function_sub, + function_div, + function_mod, + function_expt, + function_move, + function_shl, + function_shr, + function_ror, + function_rol, + function_and, + function_or, + function_xor, + function_not, + function_sel, + function_max, + function_min, + function_limit, + function_mux, + function_gt, + function_ge, + function_eq, + function_lt, + function_le, + function_ne, + function_len, + function_left, + function_right, + function_mid, + function_concat, + function_insert, + function_delete, + function_replace, + function_find, + function_none +} function_type_t; diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/generate_c.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/generate_c.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,1573 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * This is one of the versions available for the 4th stage. + * + * This 4th stage generates a c++ source program equivalent + * to the IL and ST code. + */ + + + + + + +// #include /* required for NULL */ +#include +#include +#include +#include + +#include "../../util/symtable.hh" +#include "../../util/dsymtable.hh" +#include "../../absyntax/visitor.hh" + +#include "../stage4.hh" + + + + + + + + +//#define DEBUG +#ifdef DEBUG +#define TRACE(classname) printf("\n____%s____\n",classname); +#else +#define TRACE(classname) +#endif + + + +#define ERROR error_exit(__FILE__,__LINE__) +/* function defined in main.cc */ +extern void error_exit(const char *file_name, int line_no); + + + + + + + +/* A symbol table with all globally declared functions... */ +function_declaration_c null_symbol1(NULL,NULL,NULL,NULL); +dsymtable_c function_symtable; + +/* A symbol table with all globally declared functions block types... */ +function_block_declaration_c null_symbol2(NULL,NULL,NULL); +symtable_c function_block_type_symtable; + +/* A symbol table with all globally declared program types... */ +program_declaration_c null_symbol3(NULL,NULL,NULL); +symtable_c program_type_symtable; + +/* A symbol table with all user declared type definitions... */ +/* Note that function block types and program types have their + * own symbol tables, so do not get placed in this symbol table! + */ +symbol_c null_symbol4; +symtable_c type_symtable; + + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + + +/* returns 0 if the names are equal!! */ +/* NOTE: it must ignore case!! */ +static int compare_identifiers(symbol_c *ident1, symbol_c *ident2) { + + token_c *name1 = dynamic_cast(ident1); + token_c *name2 = dynamic_cast(ident2); + + if ((name1 == NULL) || (name2 == NULL)) + /* invalid identifiers... */ + return -1; + + if (strcasecmp(name1->value, name2->value) == 0) + return 0; + + /* identifiers do not match! */ + return 1; +} + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + +/* Unlike Programs and Configurations which get mapped onto C++ classes, + * Function Blocks are mapped onto a C structure containing the variables, and + * a C function containing the code in the FB's body. This is to allow direct allocation + * of a FB variable (which is really an instance of the C data structure) to + * a member of a union variable (note that classes with constructors cannot + * be mebers of a union), which is done in IL when loading a FB onto IL's + * default variable. + * + * So as not to clash the names of the C data structure and the C function, + * the C structure is given a name identical to that of the FB name, whereas + * the name of the function is the FB name with a constant string appended. + * The value of that constant string which is appended is defined in the following + * constant. + * In order not to clash with any variable in the IL and ST source codem the + * following constant should contain a double underscore, which is not allowed + * in IL and ST. + * + * e.g.: FUNTION_BLOCK TEST + * is mapped onto a TEST data structure, and a TEST_body__ function. + */ + +#define FB_FUNCTION_SUFFIX "_body__" + +/* Idem as body, but for initializer FB function */ +#define FB_INIT_SUFFIX "_init__" + +/* Idem as body, but for run CONFIG and RESOURCE function */ +#define FB_RUN_SUFFIX "_run__" + +/* The FB body function is passed as the only parameter a pointer to the FB data + * structure instance. The name of this parameter is given by the following constant. + * In order not to clash with any variable in the IL and ST source codem the + * following constant should contain a double underscore, which is not allowed + * in IL and ST. + * + * e.g.: the body of FUNTION_BLOCK TEST + * is mapped onto the C function + * TEST_body__(TEST *data__) + */ + +#define FB_FUNCTION_PARAM "data__" + + +#define SFC_STEP_ACTION_PREFIX "__SFC_" + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + + +#include "spec_init_separator.cc" +#include "function_param_iterator.cc" +#include "function_call_iterator.cc" +#include "function_call_param_iterator.cc" +#include "type_initial_value.cc" +#include "search_fb_instance_decl.cc" +#include "search_base_type.cc" +#include "search_var_instance_decl.cc" +#include "decompose_var_instance_name.cc" +#include "search_varfb_instance_type.cc" +#include "search_constant_type.cc" +#include "search_expression_type.cc" + +#include "generate_c_base.cc" +#include "generate_c_typedecl.cc" +#include "generate_c_sfcdecl.cc" +#include "generate_c_vardecl.cc" +#include "generate_c_configbody.cc" +#include "generate_location_list.cc" + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + +/* Generate a name for a temporary variable. + * Each new name generated is appended a different number, + * starting off from 0. + * After calling reset(), the names will start off again from 0. + */ +#define VAR_LEADER "__" +#define TEMP_VAR VAR_LEADER "TMP_" +#define SOURCE_VAR VAR_LEADER "SRC_" + +#include "generate_c_tempvardecl.cc" + +#include "generate_c_st.cc" +#include "generate_c_il.cc" + +#include "generate_c.hh" + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + +#define MILLISECOND 1000000 +#define SECOND 1000 * MILLISECOND + +/* A helper class that knows how to generate code for both the IL and ST languages... */ +class calculate_time_c: public iterator_visitor_c { + private: + unsigned long time; + float current_value; + + public: + calculate_time_c(void){time = 0;}; + + unsigned long get_time(void) {return time;}; + + void *get_integer_value(token_c *token) { + std::string str = ""; + for (unsigned int i = 0; i < strlen(token->value); i++) + if (token->value[i] != '_') + str += token->value[i]; + current_value = atof(str.c_str()); + return NULL; + } + + void *get_float_value(token_c *token) { + current_value = atof(token->value); + return NULL; + } + +/******************************/ +/* B 1.2.1 - Numeric Literals */ +/******************************/ + + void *visit(integer_c *symbol) {return get_integer_value(symbol);} + +/************************/ +/* B 1.2.3.1 - Duration */ +/************************/ + + /* SYM_REF2(duration_c, neg, interval) */ + void *visit(duration_c *symbol) { + if (symbol->neg != NULL) + ERROR; + symbol->interval->accept(*this); + return NULL; + } + + /* SYM_TOKEN(fixed_point_c) */ + void *visit(fixed_point_c *symbol) {return get_float_value(symbol);} + + /* SYM_REF2(days_c, days, hours) */ + void *visit(days_c *symbol) { + if (symbol->hours) + symbol->hours->accept(*this); + symbol->days->accept(*this); + time += (unsigned long)(current_value * 24 * 3600 * SECOND); + return NULL; + } + + /* SYM_REF2(hours_c, hours, minutes) */ + void *visit(hours_c *symbol) { + if (symbol->minutes) + symbol->minutes->accept(*this); + symbol->hours->accept(*this); + time += (unsigned long)(current_value * 3600 * SECOND); + return NULL; + } + + /* SYM_REF2(minutes_c, minutes, seconds) */ + void *visit(minutes_c *symbol) { + if (symbol->seconds) + symbol->seconds->accept(*this); + symbol->minutes->accept(*this); + time += (unsigned long)(current_value * 60 * SECOND); + return NULL; + } + + /* SYM_REF2(seconds_c, seconds, milliseconds) */ + void *visit(seconds_c *symbol) { + if (symbol->milliseconds) + symbol->milliseconds->accept(*this); + symbol->seconds->accept(*this); + time += (unsigned long)(current_value * SECOND); + return NULL; + } + + /* SYM_REF2(milliseconds_c, milliseconds, unused) */ + void *visit(milliseconds_c *symbol) { + symbol->milliseconds->accept(*this); + time += (unsigned long)(current_value * MILLISECOND); + return NULL; + } +}; + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + +class calculate_common_ticktime_c: public iterator_visitor_c { + private: + unsigned long common_ticktime; + + public: + calculate_common_ticktime_c(void){common_ticktime = 0;} + + unsigned long euclide(unsigned long a, unsigned long b) { + unsigned long c = a % b; + if (c == 0) + return b; + else + return euclide(b, c); + } + + void update_ticktime(unsigned long time) { + if (common_ticktime == 0) + common_ticktime = time; + else if (time > common_ticktime) + common_ticktime = euclide(time, common_ticktime); + else + common_ticktime = euclide(common_ticktime, time); + } + + unsigned long get_ticktime(void) { + return common_ticktime; + } + +/* TASK task_name task_initialization */ +//SYM_REF2(task_configuration_c, task_name, task_initialization) + void *visit(task_initialization_c *symbol) { + calculate_time_c calculate_time; + unsigned long time = 0; + if (symbol->interval_data_source != NULL) { + symbol->interval_data_source->accept(calculate_time); + time = calculate_time.get_time(); + } + if (time > 0) + update_ticktime(time); + return NULL; + } +}; + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + +/* A helper class that knows how to generate code for both the IL and ST languages... */ +class generate_c_SFC_IL_ST_c: public null_visitor_c { + private: + stage4out_c *s4o_ptr; + symbol_c *scope; + const char *variable_prefix; + + public: + generate_c_SFC_IL_ST_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL); + /*********************************************/ + /* B.1.6 Sequential function chart elements */ + /*********************************************/ + + /*| sequential_function_chart sfc_network*/ + void *visit(sequential_function_chart_c * symbol); + + /****************************************/ + /* B.2 - Language IL (Instruction List) */ + /****************************************/ + + /***********************************/ + /* B 2.1 Instructions and Operands */ + /***********************************/ + /*| instruction_list il_instruction */ + void *visit(instruction_list_c *symbol); + + /* Remainder implemented in generate_c_il_c... */ + + /***************************************/ + /* B.3 - Language ST (Structured Text) */ + /***************************************/ + /***********************/ + /* B 3.1 - Expressions */ + /***********************/ + /* Implemented in generate_c_st_c */ + + /********************/ + /* B 3.2 Statements */ + /********************/ + void *visit(statement_list_c *symbol); + +/* Remainder implemented in generate_c_st_c... */ +}; + +#include "generate_c_sfc.cc" + +generate_c_SFC_IL_ST_c::generate_c_SFC_IL_ST_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix) { + if (NULL == scope) ERROR; + this->s4o_ptr = s4o_ptr; + this->scope = scope; + this->variable_prefix = variable_prefix; +} + +void *generate_c_SFC_IL_ST_c::visit(sequential_function_chart_c * symbol) { + generate_c_sfc_c generate_c_sfc(s4o_ptr, scope, variable_prefix); + generate_c_sfc.generate(symbol); + return NULL; +} + +void *generate_c_SFC_IL_ST_c::visit(instruction_list_c *symbol) { + generate_c_il_c generate_c_il(s4o_ptr, scope, variable_prefix); + generate_c_il.generate(symbol); + return NULL; +} + +void *generate_c_SFC_IL_ST_c::visit(statement_list_c *symbol) { + generate_c_st_c generate_c_st(s4o_ptr, scope, variable_prefix); + generate_c_st.generate(symbol); + return NULL; +} + + + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + + +class generate_c_pous_c: public generate_c_typedecl_c { + + public: + generate_c_pous_c(stage4out_c *s4o_ptr) + : generate_c_typedecl_c(s4o_ptr) {}; + virtual ~generate_c_pous_c(void) {} + + + public: + +/*************************/ +/* B.1 - Common elements */ +/*************************/ +/*******************************************/ +/* B 1.1 - Letters, digits and identifiers */ +/*******************************************/ + /* done in base class(es) */ + +/*********************/ +/* B 1.2 - Constants */ +/*********************/ + /* originally empty... */ + +/******************************/ +/* B 1.2.1 - Numeric Literals */ +/******************************/ + /* done in base class(es) */ + +/*******************************/ +/* B.1.2.2 Character Strings */ +/*******************************/ + /* done in base class(es) */ + +/***************************/ +/* B 1.2.3 - Time Literals */ +/***************************/ +/************************/ +/* B 1.2.3.1 - Duration */ +/************************/ + /* done in base class(es) */ + +/************************************/ +/* B 1.2.3.2 - Time of day and Date */ +/************************************/ + /* done in base class(es) */ + +/**********************/ +/* B.1.3 - Data types */ +/**********************/ +/***********************************/ +/* B 1.3.1 - Elementary Data Types */ +/***********************************/ + /* done in base class(es) */ + +/********************************/ +/* B.1.3.2 - Generic data types */ +/********************************/ + /* originally empty... */ + +/********************************/ +/* B 1.3.3 - Derived data types */ +/********************************/ + /* done in base class(es) */ + +/*********************/ +/* B 1.4 - Variables */ +/*********************/ + /* done in base class(es) */ + +/********************************************/ +/* B.1.4.1 Directly Represented Variables */ +/********************************************/ + /* done in base class(es) */ + +/*************************************/ +/* B.1.4.2 Multi-element Variables */ +/*************************************/ + /* done in base class(es) */ + +/******************************************/ +/* B 1.4.3 - Declaration & Initialisation */ +/******************************************/ + /* done in base class(es) */ + +/**************************************/ +/* B.1.5 - Program organization units */ +/**************************************/ +/***********************/ +/* B 1.5.1 - Functions */ +/***********************/ + +public: +/* FUNCTION derived_function_name ':' elementary_type_name io_OR_function_var_declarations_list function_body END_FUNCTION */ +/* | FUNCTION derived_function_name ':' derived_type_name io_OR_function_var_declarations_list function_body END_FUNCTION */ +void *visit(function_declaration_c *symbol) { + generate_c_vardecl_c *vardecl; + TRACE("function_declaration_c"); + + /* start off by adding this declaration to the global + * function declaration symbol table... + */ + function_symtable.insert(symbol->derived_function_name, symbol); + + /* (A) Function declaration... */ + /* (A.1) Function return type */ + s4o.print("// FUNCTION\n"); + symbol->type_name->accept(*this); /* return type */ + s4o.print(" "); + /* (A.2) Function name */ + symbol->derived_function_name->accept(*this); + s4o.print("("); + + /* (A.3) Function parameters */ + s4o.indent_right(); + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::finterface_vf, + generate_c_vardecl_c::input_vt | + generate_c_vardecl_c::output_vt | + generate_c_vardecl_c::inoutput_vt); + vardecl->print(symbol->var_declarations_list); + delete vardecl; + s4o.indent_left(); + + s4o.print(")\n" + s4o.indent_spaces + "{\n"); + + /* (B) Function local variable declaration */ + /* (B.1) Variables declared in ST source code */ + s4o.indent_right(); + vardecl = new generate_c_vardecl_c(&s4o, generate_c_vardecl_c::localinit_vf, generate_c_vardecl_c::private_vt); + vardecl->print(symbol->var_declarations_list); + delete vardecl; + + /* (B.2) Temporary variable for function's return value */ + /* It will have the same name as the function itself! */ + s4o.print(s4o.indent_spaces); + symbol->type_name->accept(*this); /* return type */ + s4o.print(" "); + symbol->derived_function_name->accept(*this); + s4o.print(" = "); + { + /* get the default value of this variable's type */ + symbol_c *default_value = (symbol_c *)symbol->type_name->accept(*type_initial_value_c::instance()); + if (default_value == NULL) ERROR; + default_value->accept(*this); + } + s4o.print(";\n\n"); + + /* (C) Function body */ + generate_c_SFC_IL_ST_c generate_c_code(&s4o, symbol); + symbol->function_body->accept(generate_c_code); + s4o.print(s4o.indent_spaces + "return "); + symbol->derived_function_name->accept(*this); + s4o.print(";\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n\n\n"); + + return NULL; +} + + +/* The remaining var_declarations_list_c, function_var_decls_c + * and var2_init_decl_list_c are handled in the generate_c_vardecl_c class + */ + + +/*****************************/ +/* B 1.5.2 - Function Blocks */ +/*****************************/ +public: +/* FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */ +//SYM_REF4(function_block_declaration_c, fblock_name, var_declarations, fblock_body, unused) +void *visit(function_block_declaration_c *symbol) { + generate_c_vardecl_c *vardecl; + generate_c_sfcdecl_c *sfcdecl; + TRACE("function_block_declaration_c"); + + /* start off by adding this declaration to the global + * function block declaration symbol table... + */ + function_block_type_symtable.insert(symbol->fblock_name, symbol); + + /* (A) Function Block data structure declaration... */ + /* (A.1) Data structure declaration */ + s4o.print("// FUNCTION_BLOCK "); + symbol->fblock_name->accept(*this); + s4o.print("\n// Data part\n"); + s4o.print("typedef struct {\n"); + s4o.indent_right(); + /* (A.2) Public variables: i.e. the function parameters... */ + s4o.print(s4o.indent_spaces + "// FB Interface - IN, OUT, IN_OUT variables\n"); + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::local_vf, + generate_c_vardecl_c::input_vt | + generate_c_vardecl_c::output_vt | + generate_c_vardecl_c::inoutput_vt); + vardecl->print(symbol->var_declarations); + delete vardecl; + s4o.print("\n"); + /* (A.3) Private internal variables */ + s4o.print(s4o.indent_spaces + "// FB private variables - TEMP, private and located variables\n"); + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::local_vf, + generate_c_vardecl_c::temp_vt | + generate_c_vardecl_c::private_vt | + generate_c_vardecl_c::located_vt | + generate_c_vardecl_c::external_vt); + vardecl->print(symbol->var_declarations); + delete vardecl; + /* (A.4) Generate private internal variables for SFC */ + sfcdecl = new generate_c_sfcdecl_c(&s4o, generate_c_sfcdecl_c::sfcdecl_sd); + sfcdecl->print(symbol->fblock_body); + delete sfcdecl; + s4o.print("\n"); + + /* (A.5) Function Block data structure type name. */ + s4o.indent_left(); + s4o.print("} "); + symbol->fblock_name->accept(*this); + s4o.print(";\n\n"); + + + /* (B) Constructor */ + /* (B.1) Constructor name... */ + s4o.print(s4o.indent_spaces + "void "); + symbol->fblock_name->accept(*this); + s4o.print(FB_INIT_SUFFIX); + s4o.print("("); + + /* first and only parameter is a pointer to the data */ + symbol->fblock_name->accept(*this); + s4o.print(" *"); + s4o.print(FB_FUNCTION_PARAM); + s4o.print(") {\n"); + s4o.indent_right(); + + /* (B.2) Member initializations... */ + s4o.print(s4o.indent_spaces); + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::constructorinit_vf, + generate_c_vardecl_c::input_vt | + generate_c_vardecl_c::output_vt | + generate_c_vardecl_c::inoutput_vt | + generate_c_vardecl_c::private_vt | + generate_c_vardecl_c::located_vt | + generate_c_vardecl_c::external_vt); + vardecl->print(symbol->var_declarations, NULL, FB_FUNCTION_PARAM"->"); + delete vardecl; + s4o.print("\n"); + /* (B.3) Generate private internal variables for SFC */ + sfcdecl = new generate_c_sfcdecl_c(&s4o, generate_c_sfcdecl_c::sfcinit_sd); + sfcdecl->print(symbol->fblock_body, FB_FUNCTION_PARAM"->"); + delete sfcdecl; + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n\n"); + + + /* (C) Function with FB body */ + /* (C.1) Step definitions */ + sfcdecl = new generate_c_sfcdecl_c(&s4o, generate_c_sfcdecl_c::stepdef_sd); + sfcdecl->print(symbol->fblock_body); + delete sfcdecl; + + /* (C.2) Action definitions */ + sfcdecl = new generate_c_sfcdecl_c(&s4o, generate_c_sfcdecl_c::actiondef_sd); + sfcdecl->print(symbol->fblock_body); + delete sfcdecl; + + /* (C.3) Function declaration */ + s4o.print("// Code part\n"); + /* function interface */ + s4o.print("void "); + symbol->fblock_name->accept(*this); + s4o.print(FB_FUNCTION_SUFFIX); + s4o.print("("); + /* first and only parameter is a pointer to the data */ + symbol->fblock_name->accept(*this); + s4o.print(" *"); + s4o.print(FB_FUNCTION_PARAM); + s4o.print(") {\n"); + s4o.indent_right(); + + /* (C.4) Initialize TEMP variables */ + /* function body */ + s4o.print(s4o.indent_spaces + "// Initialise TEMP variables\n"); + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::init_vf, + generate_c_vardecl_c::temp_vt); + vardecl->print(symbol->var_declarations, NULL, FB_FUNCTION_PARAM"->"); + delete vardecl; + s4o.print("\n"); + + /* (C.5) Function code */ + generate_c_SFC_IL_ST_c generate_c_code(&s4o, symbol, FB_FUNCTION_PARAM"->"); + symbol->fblock_body->accept(generate_c_code); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "} // "); + symbol->fblock_name->accept(*this); + s4o.print(FB_FUNCTION_SUFFIX); + s4o.print(s4o.indent_spaces + "() \n\n"); + + /* (C.6) Step undefinitions */ + sfcdecl = new generate_c_sfcdecl_c(&s4o, generate_c_sfcdecl_c::stepundef_sd); + sfcdecl->print(symbol->fblock_body); + delete sfcdecl; + + /* (C.7) Action undefinitions */ + sfcdecl = new generate_c_sfcdecl_c(&s4o, generate_c_sfcdecl_c::actionundef_sd); + sfcdecl->print(symbol->fblock_body); + delete sfcdecl; + + s4o.indent_left(); + s4o.print("\n\n\n\n"); + + return NULL; +} + + +/* The remaining temp_var_decls_c, temp_var_decls_list_c + * and non_retentive_var_decls_c are handled in the generate_c_vardecl_c class + */ + + +/**********************/ +/* B 1.5.3 - Programs */ +/**********************/ + + + +public: +/* PROGRAM program_type_name program_var_declarations_list function_block_body END_PROGRAM */ +//SYM_REF4(program_declaration_c, program_type_name, var_declarations, function_block_body, unused) +void *visit(program_declaration_c *symbol) { + generate_c_vardecl_c *vardecl; + generate_c_sfcdecl_c *sfcdecl; + TRACE("program_declaration_c"); + + /* start off by adding this declaration to the global + * program declaration symbol table... + */ + program_type_symtable.insert(symbol->program_type_name, symbol); + + /* (A) Program data structure declaration... */ + /* (A.1) Data structure declaration */ + s4o.print("// PROGRAM "); + symbol->program_type_name->accept(*this); + s4o.print("\n// Data part\n"); + s4o.print("typedef struct {\n"); + s4o.indent_right(); + + /* (A.2) Public variables: i.e. the program parameters... */ + s4o.print(s4o.indent_spaces + "// PROGRAM Interface - IN, OUT, IN_OUT variables\n"); + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::local_vf, + generate_c_vardecl_c::input_vt | + generate_c_vardecl_c::output_vt | + generate_c_vardecl_c::inoutput_vt); + vardecl->print(symbol->var_declarations); + delete vardecl; + s4o.print("\n"); + /* (A.3) Private internal variables */ + s4o.print(s4o.indent_spaces + "// PROGRAM private variables - TEMP, private and located variables\n"); + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::local_vf, + generate_c_vardecl_c::temp_vt | + generate_c_vardecl_c::private_vt | + generate_c_vardecl_c::located_vt | + generate_c_vardecl_c::external_vt); + vardecl->print(symbol->var_declarations); + delete vardecl; + /* (A.4) Generate private internal variables for SFC */ + sfcdecl = new generate_c_sfcdecl_c(&s4o, generate_c_sfcdecl_c::sfcdecl_sd); + sfcdecl->print(symbol->function_block_body); + delete sfcdecl; + + /* (A.5) Program data structure type name. */ + s4o.indent_left(); + s4o.print("} "); + symbol->program_type_name->accept(*this); + s4o.print(";\n\n"); + + /* (B) Constructor */ + /* (B.1) Constructor name... */ + s4o.print(s4o.indent_spaces + "void "); + symbol->program_type_name->accept(*this); + s4o.print(FB_INIT_SUFFIX); + s4o.print("("); + + /* first and only parameter is a pointer to the data */ + symbol->program_type_name->accept(*this); + s4o.print(" *"); + s4o.print(FB_FUNCTION_PARAM); + s4o.print(") {\n"); + s4o.indent_right(); + + /* (B.2) Member initializations... */ + s4o.print(s4o.indent_spaces); + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::constructorinit_vf, + generate_c_vardecl_c::input_vt | + generate_c_vardecl_c::output_vt | + generate_c_vardecl_c::inoutput_vt | + generate_c_vardecl_c::private_vt | + generate_c_vardecl_c::located_vt | + generate_c_vardecl_c::external_vt); + vardecl->print(symbol->var_declarations, NULL, FB_FUNCTION_PARAM"->"); + delete vardecl; + s4o.print("\n"); + /* (B.3) Generate private internal variables for SFC */ + sfcdecl = new generate_c_sfcdecl_c(&s4o, generate_c_sfcdecl_c::sfcinit_sd); + sfcdecl->print(symbol->function_block_body,FB_FUNCTION_PARAM"->"); + delete sfcdecl; + + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n\n"); + + /* (C) Function with PROGRAM body */ + /* (C.1) Step definitions */ + sfcdecl = new generate_c_sfcdecl_c(&s4o, generate_c_sfcdecl_c::stepdef_sd); + sfcdecl->print(symbol->function_block_body); + delete sfcdecl; + + /* (C.2) Action definitions */ + sfcdecl = new generate_c_sfcdecl_c(&s4o, generate_c_sfcdecl_c::actiondef_sd); + sfcdecl->print(symbol->function_block_body); + delete sfcdecl; + + /* (C.3) Function declaration */ + s4o.print("// Code part\n"); + /* function interface */ + s4o.print("void "); + symbol->program_type_name->accept(*this); + s4o.print(FB_FUNCTION_SUFFIX); + s4o.print("("); + /* first and only parameter is a pointer to the data */ + symbol->program_type_name->accept(*this); + s4o.print(" *"); + s4o.print(FB_FUNCTION_PARAM); + s4o.print(") {\n"); + s4o.indent_right(); + + /* (C.4) Initialize TEMP variables */ + /* function body */ + s4o.print(s4o.indent_spaces + "// Initialise TEMP variables\n"); + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::init_vf, + generate_c_vardecl_c::temp_vt); + vardecl->print(symbol->var_declarations, NULL, FB_FUNCTION_PARAM"->"); + delete vardecl; + s4o.print("\n"); + + /* (C.5) Function code */ + generate_c_SFC_IL_ST_c generate_c_code(&s4o, symbol, FB_FUNCTION_PARAM"->"); + symbol->function_block_body->accept(generate_c_code); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "} // "); + symbol->program_type_name->accept(*this); + s4o.print(FB_FUNCTION_SUFFIX); + s4o.print(s4o.indent_spaces + "() \n\n"); + + /* (C.6) Step undefinitions */ + sfcdecl = new generate_c_sfcdecl_c(&s4o, generate_c_sfcdecl_c::stepundef_sd); + sfcdecl->print(symbol->function_block_body); + delete sfcdecl; + + /* (C.7) Action undefinitions */ + sfcdecl = new generate_c_sfcdecl_c(&s4o, generate_c_sfcdecl_c::actionundef_sd); + sfcdecl->print(symbol->function_block_body); + delete sfcdecl; + + s4o.indent_left(); + s4o.print("\n\n\n\n"); + + return NULL; +} + +}; /* generate_c_pous_c */ + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + +class generate_c_config_c: public generate_c_typedecl_c { + + public: + generate_c_config_c(stage4out_c *s4o_ptr) + : generate_c_typedecl_c(s4o_ptr) {}; + virtual ~generate_c_config_c(void) {} + + typedef enum { + initprotos_dt, + initdeclare_dt, + runprotos_dt, + rundeclare_dt + } declaretype_t; + + declaretype_t wanted_declaretype; + +/********************************/ +/* B 1.7 Configuration elements */ +/********************************/ + + +public: +/* +CONFIGURATION configuration_name + optional_global_var_declarations + (resource_declaration_list | single_resource_declaration) + optional_access_declarations + optional_instance_specific_initializations +END_CONFIGURATION +*/ +/* +SYM_REF6(configuration_declaration_c, configuration_name, global_var_declarations, resource_declarations, access_declarations, instance_specific_initializations, unused) +*/ +void *visit(configuration_declaration_c *symbol) { + generate_c_vardecl_c *vardecl; + + /* Insert the header... */ + s4o.print("/*******************************************/\n"); + s4o.print("/* FILE GENERATED BY iec2c */\n"); + s4o.print("/* Editing this file is not recommended... */\n"); + s4o.print("/*******************************************/\n\n"); + s4o.print("#include \"iec_std_lib.h\"\n\n"); + + /* (A) configuration declaration... */ + /* (A.1) configuration name in comment */ + s4o.print("// CONFIGURATION "); + symbol->configuration_name->accept(*this); + s4o.print("\n"); + + /* (A.2) Global variables */ + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::local_vf, + generate_c_vardecl_c::global_vt); + vardecl->print(symbol); + delete vardecl; + s4o.print("\n"); + + /* (B) Initialisation Function */ + /* (B.1) Ressources initialisation protos... */ + wanted_declaretype = initprotos_dt; + symbol->resource_declarations->accept(*this); + s4o.print("\n"); + + /* (B.2) Initialisation function name... */ + s4o.print(s4o.indent_spaces + "void config"); + s4o.print(FB_INIT_SUFFIX); + s4o.print("(void) {\n"); + s4o.indent_right(); + + /* (B.3) Global variables initializations... */ + s4o.print(s4o.indent_spaces); + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::constructorinit_vf, + generate_c_vardecl_c::global_vt); + vardecl->print(symbol); + delete vardecl; + s4o.print("\n"); + + /* (B.3) Resources initializations... */ + wanted_declaretype = initdeclare_dt; + symbol->resource_declarations->accept(*this); + + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n\n"); + + + /* (C) Run Function*/ + /* (C.1) Resources run functions protos... */ + wanted_declaretype = runprotos_dt; + symbol->resource_declarations->accept(*this); + s4o.print("\n"); + + /* (C.2) Run function name... */ + s4o.print(s4o.indent_spaces + "void config"); + s4o.print(FB_RUN_SUFFIX); + s4o.print("(int tick) {\n"); + s4o.indent_right(); + + /* (C.3) Resources initializations... */ + wanted_declaretype = rundeclare_dt; + symbol->resource_declarations->accept(*this); + + /* (C.3) Close Public Function body */ + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + + return NULL; +} + +void *visit(resource_declaration_c *symbol) { + if (wanted_declaretype == initprotos_dt || wanted_declaretype == runprotos_dt) { + s4o.print(s4o.indent_spaces + "void "); + symbol->resource_name->accept(*this); + if (wanted_declaretype == initprotos_dt) { + s4o.print(FB_INIT_SUFFIX); + s4o.print("(void);\n"); + } + else { + s4o.print(FB_RUN_SUFFIX); + s4o.print("(int tick);\n"); + } + } + if (wanted_declaretype == initdeclare_dt || wanted_declaretype == rundeclare_dt) { + s4o.print(s4o.indent_spaces); + symbol->resource_name->accept(*this); + if (wanted_declaretype == initdeclare_dt) { + s4o.print(FB_INIT_SUFFIX); + s4o.print("();\n"); + } + else { + s4o.print(FB_RUN_SUFFIX); + s4o.print("(tick);\n"); + } + } + return NULL; +} + +void *visit(single_resource_declaration_c *symbol) { + if (wanted_declaretype == initprotos_dt || wanted_declaretype == runprotos_dt) { + s4o.print(s4o.indent_spaces + "void RESOURCE"); + if (wanted_declaretype == initprotos_dt) { + s4o.print(FB_INIT_SUFFIX); + s4o.print("(void);\n"); + } + else { + s4o.print(FB_RUN_SUFFIX); + s4o.print("(int tick);\n"); + } + } + if (wanted_declaretype == initdeclare_dt || wanted_declaretype == rundeclare_dt) { + s4o.print(s4o.indent_spaces + "RESOURCE"); + if (wanted_declaretype == initdeclare_dt) { + s4o.print(FB_INIT_SUFFIX); + s4o.print("();\n"); + } + else { + s4o.print(FB_RUN_SUFFIX); + s4o.print("(tick);\n"); + } + } + return NULL; +} + +}; + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + + +class generate_c_resources_c: public generate_c_typedecl_c { + + search_var_instance_decl_c *search_config_instance; + search_var_instance_decl_c *search_resource_instance; + + private: + /* The name of the resource curretnly being processed... */ + symbol_c *current_resource_name; + symbol_c *current_global_vars; + + public: + generate_c_resources_c(stage4out_c *s4o_ptr, symbol_c *config_scope, symbol_c *resource_scope, unsigned long time) + : generate_c_typedecl_c(s4o_ptr) { + search_config_instance = new search_var_instance_decl_c(config_scope); + search_resource_instance = new search_var_instance_decl_c(resource_scope); + common_ticktime = time; + current_resource_name = NULL; + current_global_vars = NULL; + }; + virtual ~generate_c_resources_c(void) { + delete search_config_instance; + delete search_resource_instance; + } + + typedef enum { + declare_dt, + init_dt, + run_dt + } declaretype_t; + + declaretype_t wanted_declaretype; + + unsigned long common_ticktime; + + const char *current_program_name; + + typedef enum { + assign_at, + send_at + } assigntype_t; + + assigntype_t wanted_assigntype; + +/********************************/ +/* B 1.7 Configuration elements */ +/********************************/ + +/* +RESOURCE resource_name ON resource_type_name + optional_global_var_declarations + single_resource_declaration +END_RESOURCE +*/ +// SYM_REF4(resource_declaration_c, resource_name, resource_type_name, global_var_declarations, resource_declaration) + void *visit(resource_declaration_c *symbol) { + current_resource_name = symbol->resource_name; + current_global_vars = symbol->global_var_declarations; + + symbol->resource_declaration->accept(*this); + + current_resource_name = NULL; + current_global_vars = NULL; + return NULL; + } + +/* task_configuration_list program_configuration_list */ +// SYM_REF2(single_resource_declaration_c, task_configuration_list, program_configuration_list) + void *visit(single_resource_declaration_c *symbol) { + bool single_resource = current_resource_name == NULL; + if (single_resource) + current_resource_name = new identifier_c("RESOURCE"); + generate_c_vardecl_c *vardecl; + + /* Insert the header... */ + s4o.print("/*******************************************/\n"); + s4o.print("/* FILE GENERATED BY iec2c */\n"); + s4o.print("/* Editing this file is not recommended... */\n"); + s4o.print("/*******************************************/\n\n"); + s4o.print("#include \"iec_std_lib.h\"\n\n"); + + /* (A) resource declaration... */ + /* (A.1) resource name in comment */ + s4o.print("// RESOURCE "); + current_resource_name->accept(*this); + s4o.print("\n"); + + /* (A.2) Global variables... */ + if (current_global_vars != NULL) { + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::local_vf, + generate_c_vardecl_c::global_vt); + vardecl->print(current_global_vars); + delete vardecl; + } + s4o.print("\n"); + + /* (A.3) POUs inclusion */ + s4o.print("#include \"POUS.c\"\n\n"); + + /* (A.4) Resource programs declaration... */ + wanted_declaretype = declare_dt; + symbol->program_configuration_list->accept(*this); + s4o.print("\n"); + + /* (B) resource initialisation function... */ + /* (B.1) initialisation function name... */ + s4o.print("void "); + current_resource_name->accept(*this); + s4o.print(FB_INIT_SUFFIX); + s4o.print("(void) {\n"); + s4o.indent_right(); + + /* (B.2) Global variables initialisations... */ + if (current_global_vars != NULL) { + s4o.print(s4o.indent_spaces); + vardecl = new generate_c_vardecl_c(&s4o, + generate_c_vardecl_c::constructorinit_vf, + generate_c_vardecl_c::global_vt); + vardecl->print(current_global_vars); + delete vardecl; + } + s4o.print("\n"); + + /* (B.3) Resource programs initialisations... */ + wanted_declaretype = init_dt; + symbol->program_configuration_list->accept(*this); + + s4o.indent_left(); + s4o.print("}\n\n"); + + /* (C) Resource run function... */ + /* (C.1) Run function name... */ + s4o.print("void "); + current_resource_name->accept(*this); + s4o.print(FB_RUN_SUFFIX); + s4o.print("(int tick) {\n"); + s4o.indent_right(); + + /* (C.2) Task management... */ + symbol->task_configuration_list->accept(*this); + + /* (C.3) Program run declaration... */ + wanted_declaretype = run_dt; + symbol->program_configuration_list->accept(*this); + + s4o.indent_left(); + s4o.print("}\n\n"); + + if (single_resource) { + delete current_resource_name; + current_resource_name = NULL; + } + return NULL; + } + +/* PROGRAM [RETAIN | NON_RETAIN] program_name [WITH task_name] ':' program_type_name ['(' prog_conf_elements ')'] */ +//SYM_REF6(program_configuration_c, retain_option, program_name, task_name, program_type_name, prog_conf_elements, unused) + void *visit(program_configuration_c *symbol) { + if (wanted_declaretype == declare_dt) { + s4o.print(s4o.indent_spaces); + symbol->program_type_name->accept(*this); + s4o.print(" "); + symbol->program_name->accept(*this); + s4o.print(";\n"); + } + if (wanted_declaretype == init_dt) { + s4o.print(s4o.indent_spaces); + symbol->program_type_name->accept(*this); + s4o.print(FB_INIT_SUFFIX); + s4o.print("(&"); + symbol->program_name->accept(*this); + s4o.print(");\n"); + } + if (wanted_declaretype == run_dt) { + current_program_name = ((identifier_c*)(symbol->program_name))->value; + if (symbol->task_name != NULL) { + s4o.print(s4o.indent_spaces); + s4o.print("if (!"); + symbol->task_name->accept(*this); + s4o.print(") {\n"); + s4o.indent_right(); + } + + wanted_assigntype = assign_at; + if (symbol->prog_conf_elements != NULL) + symbol->prog_conf_elements->accept(*this); + + s4o.print(s4o.indent_spaces); + symbol->program_type_name->accept(*this); + s4o.print(FB_FUNCTION_SUFFIX); + s4o.print("(&"); + symbol->program_name->accept(*this); + s4o.print(");\n"); + + wanted_assigntype = send_at; + if (symbol->prog_conf_elements != NULL) + symbol->prog_conf_elements->accept(*this); + + if (symbol->task_name != NULL) { + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + } + } + return NULL; + } + +/* TASK task_name task_initialization */ +//SYM_REF2(task_configuration_c, task_name, task_initialization) + void *visit(task_configuration_c *symbol) { + s4o.print(s4o.indent_spaces + "int "); + symbol->task_name->accept(*this); + s4o.print(" = "); + symbol->task_initialization->accept(*this); + s4o.print(";\n"); + return NULL; + } + +/* '(' [SINGLE ASSIGN data_source ','] [INTERVAL ASSIGN data_source ','] PRIORITY ASSIGN integer ')' */ +//SYM_REF4(task_initialization_c, single_data_source, interval_data_source, priority_data_source, unused) + void *visit(task_initialization_c *symbol) { + if (symbol->interval_data_source != NULL) { + calculate_time_c calculate_time; + symbol->interval_data_source->accept(calculate_time); + unsigned long time = calculate_time.get_time(); + if (time != 0) { + s4o.print("tick % "); + s4o.print_integer((int)(time / common_ticktime)); + } + else + s4o.print("1"); + } + else + s4o.print("1"); + return NULL; + } + +/* any_symbolic_variable ASSIGN prog_data_source */ +//SYM_REF2(prog_cnxn_assign_c, symbolic_variable, prog_data_source) + void *visit(prog_cnxn_assign_c *symbol) { + if (wanted_assigntype == assign_at) { + symbol_c *var_decl; + unsigned int vartype = 0; + symbol_c *current_var_reference = ((global_var_reference_c *)(symbol->prog_data_source))->global_var_name; + var_decl = search_resource_instance->get_decl(current_var_reference); + if (var_decl == NULL) { + var_decl = search_config_instance->get_decl(current_var_reference); + if (var_decl == NULL) + ERROR; + else + vartype = search_config_instance->get_vartype(); + } + else + vartype = search_resource_instance->get_vartype(); + + s4o.print(s4o.indent_spaces + "{extern "); + var_decl->accept(*this); + s4o.print(" "); + symbol->prog_data_source->accept(*this); + s4o.print("; "); + s4o.print(current_program_name); + s4o.print("."); + symbol->symbolic_variable->accept(*this); + s4o.print(" = "); + if (vartype || search_var_instance_decl_c::global_vt) + s4o.print("*"); + symbol->prog_data_source->accept(*this); + s4o.print(";}\n"); + } + return NULL; + } + +/* any_symbolic_variable SENDTO data_sink */ +//SYM_REF2(prog_cnxn_sendto_c, symbolic_variable, data_sink) + void *visit(prog_cnxn_sendto_c *symbol) { + if (wanted_assigntype == send_at) { + symbol_c *var_decl; + unsigned int vartype = 0; + symbol_c *current_var_reference = ((global_var_reference_c *)(symbol->data_sink))->global_var_name; + var_decl = search_resource_instance->get_decl(current_var_reference); + if (var_decl == NULL) { + var_decl = search_config_instance->get_decl(current_var_reference); + if (var_decl == NULL) + ERROR; + else + vartype = search_config_instance->get_vartype(); + } + else + vartype = search_resource_instance->get_vartype(); + + s4o.print(s4o.indent_spaces); + s4o.print(s4o.indent_spaces + "{extern "); + var_decl->accept(*this); + s4o.print(" "); + symbol->data_sink->accept(*this); + s4o.print("; "); + if (vartype || search_var_instance_decl_c::global_vt) + s4o.print("*"); + symbol->data_sink->accept(*this); + s4o.print(" = "); + s4o.print(current_program_name); + s4o.print("."); + symbol->symbolic_variable->accept(*this); + s4o.print("};\n"); + } + return NULL; + } + +}; + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + +class generate_c_c: public iterator_visitor_c { + protected: + stage4out_c &s4o; + stage4out_c pous_s4o; + stage4out_c located_variables_s4o; + generate_c_pous_c generate_c_pous; + + symbol_c *current_configuration; + + const char *current_name; + const char *current_builddir; + + unsigned long common_ticktime; + + public: + generate_c_c(stage4out_c *s4o_ptr, const char *builddir): + s4o(*s4o_ptr), + pous_s4o(builddir, "POUS", "c"), + located_variables_s4o(builddir, "LOCATED_VARIABLES","h"), + generate_c_pous(&pous_s4o) { + current_builddir = builddir; + current_configuration = NULL; + } + + ~generate_c_c(void) {} + +/***************************/ +/* B 0 - Programming Model */ +/***************************/ + void *visit(library_c *symbol) { + generate_location_list_c generate_location_list(&located_variables_s4o); + symbol->accept(generate_location_list); + + for(int i = 0; i < symbol->n; i++) { + symbol->elements[i]->accept(*this); + } + return NULL; + } + +/*************************/ +/* B.1 - Common elements */ +/*************************/ +/*******************************************/ +/* B 1.1 - Letters, digits and identifiers */ +/*******************************************/ + void *visit(identifier_c *symbol) { + current_name = symbol->value; + return NULL; + } + +/**************************************/ +/* B.1.5 - Program organization units */ +/**************************************/ +/***********************/ +/* B 1.5.1 - Functions */ +/***********************/ + void *visit(function_declaration_c *symbol) { + symbol->accept(generate_c_pous); + return NULL; + } + +/*****************************/ +/* B 1.5.2 - Function Blocks */ +/*****************************/ + void *visit(function_block_declaration_c *symbol) { + symbol->accept(generate_c_pous); + return NULL; + } + +/**********************/ +/* B 1.5.3 - Programs */ +/**********************/ + void *visit(program_declaration_c *symbol) { + symbol->accept(generate_c_pous); + return NULL; + } + + +/********************************/ +/* B 1.7 Configuration elements */ +/********************************/ + void *visit(configuration_declaration_c *symbol) { + static int configuration_count = 0; + + if (configuration_count++) { + /* the first configuration is the one we will use!! */ + ERROR; + } + + current_configuration = symbol; + + calculate_common_ticktime_c calculate_common_ticktime; + symbol->accept(calculate_common_ticktime); + common_ticktime = calculate_common_ticktime.get_ticktime(); + + symbol->configuration_name->accept(*this); + stage4out_c config_s4o(current_builddir, current_name, "c"); + generate_c_config_c generate_c_config(&config_s4o); + symbol->accept(generate_c_config); + + config_s4o.print("int common_ticktime__ = "); + config_s4o.print_integer((int)(common_ticktime / 1000000)); + config_s4o.print("; /*ms*/\n"); + + symbol->resource_declarations->accept(*this); + + current_configuration = NULL; + + return NULL; + } + + void *visit(resource_declaration_c *symbol) { + symbol->resource_name->accept(*this); + stage4out_c resources_s4o(current_builddir, current_name, "c"); + generate_c_resources_c generate_c_resources(&resources_s4o, current_configuration, symbol, common_ticktime); + symbol->accept(generate_c_resources); + return NULL; + } + + void *visit(single_resource_declaration_c *symbol) { + stage4out_c resources_s4o(current_builddir, "RESOURCE", "c"); + generate_c_resources_c generate_c_resources(&resources_s4o, current_configuration, symbol, common_ticktime); + symbol->accept(generate_c_resources); + return NULL; + } + +}; + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + + + + +visitor_c *new_code_generator(stage4out_c *s4o, const char *builddir) {return new generate_c_c(s4o, builddir);} +void delete_code_generator(visitor_c *code_generator) {delete code_generator;} + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/generate_c.hh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/generate_c.hh Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,56 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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, ST and SFC compiler. + * + * Based on the + * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10) + * + */ + + +/* + * This is one of the versions available for the 4th stage. + * + * This 4th stage generates a c source program equivalent + * to the IL, ST and SFC code. + */ + + +/* + * generate_c.HH + */ + + +#ifndef _generate_c_HH +#define _generate_c_HH + + + +#include +#include "../../absyntax/absyntax.hh" +#include "../../absyntax/visitor.hh" + + + + + + + + +#endif /* _generate_c_H */ + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/generate_c_base.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/generate_c_base.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,668 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * Conversion of basic abstract syntax constructs. + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the IL and ST + * code. + */ + + + + + + +//#include /* required for NULL */ +//#include +//#include + +//#include "../../util/symtable.hh" + +//#include "generate_c.hh" + + + + + + + + + + + + + +class generate_c_base_c: public iterator_visitor_c { + + protected: + stage4out_c &s4o; + + private: + /* Unlike programs that are mapped onto C++ classes, Function Blocks are mapped onto a data structure type + * and a separate function conatining the code. This function is passed a pointer to an instance of the data + * structure. This means that the code inside the functions must insert a pointer to the data structure whenever + * it wishes to access a Function Block variable. + * The variable_prefix_ variable will contain the correct string which needs to be prefixed to all variable accesses. + * This string is set with the set_variable_prefix() member function. + */ + const char *variable_prefix_; + + + + public: + generate_c_base_c(stage4out_c *s4o_ptr): s4o(*s4o_ptr) {variable_prefix_ = NULL;} + ~generate_c_base_c(void) {} + + void set_variable_prefix(const char *variable_prefix) {variable_prefix_ = variable_prefix;} + void print_variable_prefix(void) { + if (variable_prefix_ != NULL) + s4o.print(variable_prefix_); + } + + void *print_token(token_c *token, int offset = 0) { + return s4o.printupper((token->value)+offset); + } + + void *print_literal(symbol_c *type, symbol_c *value) { + s4o.print("__"); + type->accept(*this); + s4o.print("_LITERAL("); + value->accept(*this); + s4o.print(")"); + return NULL; + } + + void *print_striped_token(token_c *token, int offset = 0) { + std::string str = ""; + for (unsigned int i = offset; i < strlen(token->value); i++) + if (token->value[i] != '_') + str += token->value[i]; + return s4o.printupper(str); + } + + void *print_striped_binary_token(token_c *token, unsigned int offset = 0) { + /* convert the binary value to hexadecimal format... */ + unsigned char value, bit_mult; + unsigned int i; + int total_bits; + char str[2] = {'A', '\0'}; /* since the s4o object is not prepared to print out one character at a time... */ + + s4o.print("0x"); + + total_bits = 0; + for (i = offset; i < strlen(token->value); i++) + if (token->value[i] != '_') + total_bits++; + + value = 0; + bit_mult = (unsigned char)1 << (((total_bits+3)%4)+1); + for (i = offset; i < strlen(token->value); i++) { + if (token->value[i] != '_') { + bit_mult /= 2; + value += bit_mult * ((token->value[i] == '0')? 0:1); + if (bit_mult == 1) { + str[0] = (value <= 9)? (char)'0' + value : (char)'A' + value; + s4o.print(str); + bit_mult = 0x10; + value = 0; + } + } + } + + return NULL; + } + + void *print_list(list_c *list, + std::string pre_elem_str = "", + std::string inter_elem_str = "", + std::string post_elem_str = "", + visitor_c *visitor = NULL) { + if (visitor == NULL) visitor = this; + + if (list->n > 0) { +//std::cout << "generate_c_base_c::print_list(n = " << list->n << ") 000\n"; + s4o.print(pre_elem_str); + list->elements[0]->accept(*visitor); + } + + for(int i = 1; i < list->n; i++) { +//std::cout << "generate_c_base_c::print_list " << i << "\n"; + s4o.print(inter_elem_str); + list->elements[i]->accept(*visitor); + } + + if (list->n > 0) + s4o.print(post_elem_str); + + return NULL; + } + + + void *print_binary_expression(symbol_c *l_exp, + symbol_c *r_exp, + const char *operation) { + s4o.print("("); + l_exp->accept(*this); + s4o.print(operation); + r_exp->accept(*this); + s4o.print(")"); + return NULL; + } + + void *print_unary_expression(symbol_c *exp, + const char *operation) { + s4o.print(operation); + s4o.print("("); + exp->accept(*this); + s4o.print(")"); + return NULL; + } + + void *print_binary_function(const char *function, + symbol_c *l_exp, + symbol_c *r_exp) { + s4o.print(function); + s4o.print("("); + l_exp->accept(*this); + s4o.print(", "); + r_exp->accept(*this); + s4o.print(")"); + return NULL; + } + + void *print_compare_function(const char *function, + symbol_c *compare_type, + symbol_c *l_exp, + symbol_c *r_exp) { + s4o.print(function); + compare_type->accept(*this); + s4o.print("(2, "); + l_exp->accept(*this); + s4o.print(", "); + r_exp->accept(*this); + s4o.print(")"); + return NULL; + } + +/***************************/ +/* 2.1.6 - Pragmas */ +/***************************/ + /* Do not use print_token() as it will change everything into uppercase */ + void *visit(pragma_c *symbol) {return s4o.print(symbol->value);} + + +/***************************/ +/* B 0 - Programming Model */ +/***************************/ + /* leave for derived classes... */ + + + +/*************************/ +/* B.1 - Common elements */ +/*************************/ +/*******************************************/ +/* B 1.1 - Letters, digits and identifiers */ +/*******************************************/ + void *visit(identifier_c *symbol) {return print_token(symbol);} + +/*********************/ +/* B 1.2 - Constants */ +/*********************/ + /* originally empty... */ + +/******************************/ +/* B 1.2.1 - Numeric Literals */ +/******************************/ + void *visit(real_c *symbol) {return print_striped_token(symbol);} + void *visit(integer_c *symbol) {return print_striped_token(symbol);} + void *visit(binary_integer_c *symbol) {return print_striped_binary_token(symbol, 2);} + void *visit(octal_integer_c *symbol) {s4o.print("0"); return print_striped_token(symbol, 2);} + void *visit(hex_integer_c *symbol) {s4o.print("0x"); return print_striped_token(symbol, 3);} + + void *visit(numeric_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} + void *visit(integer_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} + void *visit(real_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} + void *visit(bit_string_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} + void *visit(boolean_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} + + /* helper class for boolean_literal_c */ + void *visit(boolean_true_c *symbol) {s4o.print("TRUE"); return NULL;} + void *visit(boolean_false_c *symbol) {s4o.print("FALSE"); return NULL;} + +/*******************************/ +/* B.1.2.2 Character Strings */ +/*******************************/ + void *visit(double_byte_character_string_c *symbol) { + // TO DO ... + ERROR; + return print_token(symbol); + } + + void *visit(single_byte_character_string_c *symbol) { + std::string str = ""; + unsigned int count = 0; + str += '"'; + /* we ignore the first and last bytes, they will be the character ' */ + for (unsigned int i = 1; i < strlen(symbol->value) - 1; i++) { + char c = symbol->value[i]; + if ((c == '\\') || (c == '"')) + {str += '\\'; str += c; count ++; continue;} + if (c != '$') + {str += c; count++; continue;} + /* this should be safe, since the code has passed the syntax parser!! */ + c = symbol->value[++i]; + switch (c) { + case '$': + case '\'': + {str += c; count++; continue;} + case 'L': + case 'l': + {str += "\x0A"; /* LF */; count++; continue;} + case 'N': + case 'n': + {str += "\\x0A"; /* NL */; count++; continue;} + case 'P': + case 'p': + {str += "\\f"; /* FF */; count++; continue;} + case 'R': + case 'r': + {str += "\\r"; /* CR */; count++; continue;} + case 'T': + case 't': + {str += "\\t"; /* tab */; count++; continue;} + default: { + if (isxdigit(c)) { + /* this should be safe, since the code has passed the syntax parser!! */ + char c2 = symbol->value[++i]; + if (isxdigit(c2)) { + str += '\\'; str += 'x'; str += c; str += c2; + count++; continue; + } + } + } + /* otherwise we have an invalid string!! */ + /* This should not have got through the syntax parser! */ + ERROR; + } /* switch() */ + } /* for() */ + + str += '"'; + s4o.print("(STRING){"); + s4o.print_integer(count); + s4o.print(","); + s4o.print(str); + s4o.print("}"); + return NULL; + } + + +/***************************/ +/* B 1.2.3 - Time Literals */ +/***************************/ + +/************************/ +/* B 1.2.3.1 - Duration */ +/************************/ +/* The following output is actually the parameters to the constructor of the TIME class! */ + +/* SYM_REF0(neg_time_c) */ +void *visit(neg_time_c *symbol) {s4o.print("-1"); /* negative time value */; return NULL;} + + +/* SYM_REF2(duration_c, neg, interval) */ +void *visit(duration_c *symbol) { + TRACE("duration_c"); + s4o.print("__time_to_timespec("); + if (NULL == symbol->neg) + s4o.print("1"); /* positive time value */ + else + symbol->neg->accept(*this); /* this will print '-1' :-) */ + + s4o.print(", "); + + symbol->interval->accept(*this); + if (typeid(*symbol->interval) == typeid(hours_c)) {s4o.print(", 0");} + if (typeid(*symbol->interval) == typeid(minutes_c)) {s4o.print(", 0, 0");} + if (typeid(*symbol->interval) == typeid(seconds_c)) {s4o.print(", 0, 0, 0");} + if (typeid(*symbol->interval) == typeid(milliseconds_c)) {s4o.print(", 0, 0, 0, 0");} + s4o.print(")"); + return NULL; +} + + +/* SYM_TOKEN(fixed_point_c) */ +void *visit(fixed_point_c *symbol) {return print_token(symbol);} + + +/* SYM_REF2(days_c, days, hours) */ +void *visit(days_c *symbol) { + TRACE("days_c"); + if (NULL == symbol->hours) + s4o.print("0, 0, 0, 0"); /* milliseconds, seconds, minutes, hours */ + else + symbol->hours->accept(*this); + + s4o.print(", "); + + symbol->days->accept(*this); + return NULL; +} + + +/* SYM_REF2(hours_c, hours, minutes) */ +void *visit(hours_c *symbol) { + TRACE("hours_c"); + if (NULL == symbol->minutes) + s4o.print("0, 0, 0"); /* milliseconds, seconds, minutes */ + else + symbol->minutes->accept(*this); + + s4o.print(", "); + + symbol->hours->accept(*this); + return NULL; +} + + +/* SYM_REF2(minutes_c, minutes, seconds) */ +void *visit(minutes_c *symbol) { + TRACE("minutes_c"); + if (NULL == symbol->seconds) + s4o.print("0, 0"); /* milliseconds, seconds */ + else + symbol->seconds->accept(*this); + + s4o.print(", "); + + symbol->minutes->accept(*this); + return NULL; +} + + +/* SYM_REF2(seconds_c, seconds, milliseconds) */ +void *visit(seconds_c *symbol) { + TRACE("seconds_c"); + if (NULL == symbol->milliseconds) + s4o.print("0"); /* milliseconds */ + else + symbol->milliseconds->accept(*this); + + s4o.print(", "); + + symbol->seconds->accept(*this); + return NULL; +} + + +/* SYM_REF2(milliseconds_c, milliseconds, unused) */ +void *visit(milliseconds_c *symbol) { + TRACE("milliseconds_c"); + symbol->milliseconds->accept(*this); + return NULL; +} + +/************************************/ +/* B 1.2.3.2 - Time of day and Date */ +/************************************/ + +/* SYM_REF2(time_of_day_c, daytime, unused) */ +void *visit(time_of_day_c *symbol) { + TRACE("time_of_day_c"); + s4o.print("__tod_to_timespec("); + symbol->daytime->accept(*this); + s4o.print(")"); + return NULL; +} + + +/* SYM_REF4(daytime_c, day_hour, day_minute, day_second, unused) */ +void *visit(daytime_c *symbol) { + TRACE("daytime_c"); + symbol->day_second->accept(*this); + s4o.print(", "); + symbol->day_minute->accept(*this); + s4o.print(", "); + symbol->day_hour->accept(*this); + return NULL; +} + + +/* SYM_REF2(date_c, date_literal, unused) */ +void *visit(date_c *symbol) { + TRACE("date_c"); + s4o.print("__date_to_timespec("); + symbol->date_literal->accept(*this); + s4o.print(")"); + return NULL; +} + + +/* SYM_REF4(date_literal_c, year, month, day, unused) */ +void *visit(date_literal_c *symbol) { + TRACE("date_literal_c"); + symbol->day->accept(*this); + s4o.print(", "); + symbol->month->accept(*this); + s4o.print(", "); + symbol->year->accept(*this); + return NULL; +} + + +/* SYM_REF2(date_and_time_c, date_literal, daytime) */ +void *visit(date_and_time_c *symbol) { + TRACE("date_and_time_c"); + s4o.print("__dt_to_timespec("); + symbol->daytime->accept(*this); + s4o.print(", "); + symbol->date_literal->accept(*this); + s4o.print(")"); + return NULL; +} + + +/**********************/ +/* B.1.3 - Data types */ +/**********************/ +/***********************************/ +/* B 1.3.1 - Elementary Data Types */ +/***********************************/ + void *visit(time_type_name_c *symbol) {s4o.print("TIME"); return NULL;} + void *visit(bool_type_name_c *symbol) {s4o.print("BOOL"); return NULL;} + void *visit(sint_type_name_c *symbol) {s4o.print("SINT"); return NULL;} + void *visit(int_type_name_c *symbol) {s4o.print("INT"); return NULL;} + void *visit(dint_type_name_c *symbol) {s4o.print("DINT"); return NULL;} + void *visit(lint_type_name_c *symbol) {s4o.print("LINT"); return NULL;} + void *visit(usint_type_name_c *symbol) {s4o.print("USINT"); return NULL;} + void *visit(uint_type_name_c *symbol) {s4o.print("UINT"); return NULL;} + void *visit(udint_type_name_c *symbol) {s4o.print("UDINT"); return NULL;} + void *visit(ulint_type_name_c *symbol) {s4o.print("ULINT"); return NULL;} + void *visit(real_type_name_c *symbol) {s4o.print("REAL"); return NULL;} + void *visit(lreal_type_name_c *symbol) {s4o.print("LREAL"); return NULL;} + void *visit(date_type_name_c *symbol) {s4o.print("DATE"); return NULL;} + void *visit(tod_type_name_c *symbol) {s4o.print("TOD"); return NULL;} + void *visit(dt_type_name_c *symbol) {s4o.print("DT"); return NULL;} + void *visit(byte_type_name_c *symbol) {s4o.print("BYTE"); return NULL;} + void *visit(word_type_name_c *symbol) {s4o.print("WORD"); return NULL;} + void *visit(lword_type_name_c *symbol) {s4o.print("LWORD"); return NULL;} + void *visit(dword_type_name_c *symbol) {s4o.print("DWORD"); return NULL;} + void *visit(string_type_name_c *symbol) {s4o.print("STRING"); return NULL;} + void *visit(wstring_type_name_c *symbol) {s4o.print("WSTRING"); return NULL;} + +/********************************/ +/* B.1.3.2 - Generic data types */ +/********************************/ + /* originally empty... */ + +/********************************/ +/* B 1.3.3 - Derived data types */ +/********************************/ + /* leave for derived classes... */ + +/*********************/ +/* B 1.4 - Variables */ +/*********************/ +void *visit(symbolic_variable_c *symbol) { + TRACE("symbolic_variable_c"); + this->print_variable_prefix(); + symbol->var_name->accept(*this); + return NULL; +} + +/********************************************/ +/* B.1.4.1 Directly Represented Variables */ +/********************************************/ +void *visit(direct_variable_c *symbol) { + TRACE("direct_variable_c"); + /* Do not use print_token() as it will change everything into uppercase */ + return s4o.printlocation(symbol->value); +} + + + +/*************************************/ +/* B.1.4.2 Multi-element Variables */ +/*************************************/ +#if 0 +/* subscripted_variable '[' subscript_list ']' */ +SYM_REF2(array_variable_c, subscripted_variable, subscript_list) + +/* subscript_list ',' subscript */ +SYM_LIST(subscript_list_c) +#endif + +/* record_variable '.' field_selector */ +/* WARNING: input and/or output variables of function blocks + * may be accessed as fields of a structured variable! + * Code handling a structured_variable_c must take + * this into account! + */ +// SYM_REF2(structured_variable_c, record_variable, field_selector) +void *visit(structured_variable_c *symbol) { + TRACE("structured_variable_c"); + + symbol->record_variable->accept(*this); + s4o.print("."); + symbol->field_selector->accept(*this); + return NULL; +} + +/******************************************/ +/* B 1.4.3 - Declaration & Initialisation */ +/******************************************/ + /* leave for derived classes... */ + +/**************************************/ +/* B.1.5 - Program organization units */ +/**************************************/ +/***********************/ +/* B 1.5.1 - Functions */ +/***********************/ + /* leave for derived classes... */ + +/*****************************/ +/* B 1.5.2 - Function Blocks */ +/*****************************/ + /* leave for derived classes... */ + +/**********************/ +/* B 1.5.3 - Programs */ +/**********************/ + /* leave for derived classes... */ + +/*********************************************/ +/* B.1.6 Sequential function chart elements */ +/*********************************************/ + +/********************************/ +/* B 1.7 Configuration elements */ +/********************************/ + /* leave for derived classes... */ + +/****************************************/ +/* B.2 - Language IL (Instruction List) */ +/****************************************/ +/***********************************/ +/* B 2.1 Instructions and Operands */ +/***********************************/ + /* leave for derived classes... */ + +/*******************/ +/* B 2.2 Operators */ +/*******************/ + /* leave for derived classes... */ + + +/***************************************/ +/* B.3 - Language ST (Structured Text) */ +/***************************************/ +/***********************/ +/* B 3.1 - Expressions */ +/***********************/ + /* leave for derived classes... */ + +/********************/ +/* B 3.2 Statements */ +/********************/ + /* leave for derived classes... */ + +/*********************************/ +/* B 3.2.1 Assignment Statements */ +/*********************************/ + /* leave for derived classes... */ + +/*****************************************/ +/* B 3.2.2 Subprogram Control Statements */ +/*****************************************/ + /* leave for derived classes... */ + +/********************************/ +/* B 3.2.3 Selection Statements */ +/********************************/ + /* leave for derived classes... */ + +/********************************/ +/* B 3.2.4 Iteration Statements */ +/********************************/ + /* leave for derived classes... */ + +}; /* class generate_c_basic_c */ + + + + + + + + + + + + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/generate_c_configbody.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/generate_c_configbody.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,211 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * Build the body of the main function (currently named run() ) + * of the class onto which is mapped a specific CONFIGURATION. + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the IL and ST + * code. + */ + + + + + + +// #include /* required for NULL */ +/* +#include +#include + +#include "../../util/symtable.hh" + +#include "../stage4.hh" +*/ + + + + + +class generate_c_configbody_c: public generate_c_base_c { + + public: + generate_c_configbody_c(stage4out_c *s4o_ptr) + : generate_c_base_c(s4o_ptr) { + current_resource_name = NULL; + } + + virtual ~generate_c_configbody_c(void) {} + + + private: + /* The name of the resource curretnly being processed... */ + symbol_c *current_resource_name; + + +/********************************/ +/* B 1.7 Configuration elements */ +/********************************/ + + +public: +/* +CONFIGURATION configuration_name + optional_global_var_declarations + (resource_declaration_list | single_resource_declaration) + optional_access_declarations + optional_instance_specific_initializations +END_CONFIGURATION +*/ +/* +SYM_REF6(configuration_declaration_c, configuration_name, global_var_declarations, resource_declarations, access_declarations, instance_specific_initializations, unused) +*/ +void *visit(configuration_declaration_c *symbol) { + TRACE("configuration_declaration_c"); + + symbol->resource_declarations->accept(*this); + return NULL; +} + + + +/* helper symbol for configuration_declaration */ +// SYM_LIST(resource_declaration_list_c) +void *visit(resource_declaration_list_c *symbol) { + TRACE("resource_declaration_list_c"); + + return print_list(symbol); +} + +/* +RESOURCE resource_name ON resource_type_name + optional_global_var_declarations + single_resource_declaration +END_RESOURCE +*/ +// SYM_REF4(resource_declaration_c, resource_name, resource_type_name, global_var_declarations, resource_declaration) +void *visit(resource_declaration_c *symbol) { + TRACE("resource_declaration_c"); + + current_resource_name = symbol->resource_name; + symbol->resource_declaration->accept(*this); + current_resource_name = NULL; + return NULL; +} + + + +/* task_configuration_list program_configuration_list */ +// SYM_REF2(single_resource_declaration_c, task_configuration_list, program_configuration_list) +void *visit(single_resource_declaration_c *symbol) { + TRACE("single_resource_declaration_c"); + + symbol->program_configuration_list->accept(*this); + return NULL; +} + + + +/* helper symbol for single_resource_declaration */ +//SYM_LIST(task_configuration_list_c) + + +/* helper symbol for single_resource_declaration */ +//SYM_LIST(program_configuration_list_c) +void *visit(program_configuration_list_c *symbol) { + TRACE("program_configuration_list_c"); + + return print_list(symbol); +} + + +/* helper symbol for + * - access_path + * - instance_specific_init + */ +//SYM_LIST(any_fb_name_list_c) + +/* [resource_name '.'] global_var_name ['.' structure_element_name] */ +//SYM_REF4(global_var_reference_c, resource_name, global_var_name, structure_element_name, unused) + +/* prev_declared_program_name '.' symbolic_variable */ +//SYM_REF2(program_output_reference_c, program_name, symbolic_variable) + +/* TASK task_name task_initialization */ +//SYM_REF2(task_configuration_c, task_name, task_initialization) + +/* '(' [SINGLE ASSIGN data_source ','] [INTERVAL ASSIGN data_source ','] PRIORITY ASSIGN integer ')' */ +//SYM_REF4(task_initialization_c, single_data_source, interval_data_source, priority_data_source, unused) + +/* PROGRAM [RETAIN | NON_RETAIN] program_name [WITH task_name] ':' program_type_name ['(' prog_conf_elements ')'] */ +//SYM_REF6(program_configuration_c, retain_option, program_name, task_name, program_type_name, prog_conf_elements, unused) +void *visit(program_configuration_c *symbol) { + TRACE("program_configuration_c"); + + s4o.print(s4o.indent_spaces); + if (NULL != current_resource_name) { + current_resource_name->accept(*this); + s4o.print("."); + } + symbol->program_name->accept(*this); + s4o.print(".f();\n"); + return NULL; +} + +/* prog_conf_elements ',' prog_conf_element */ +//SYM_LIST(prog_conf_elements_c) + +/* fb_name WITH task_name */ +//SYM_REF2(fb_task_c, fb_name, task_name) +// TODO... + +/* any_symbolic_variable ASSIGN prog_data_source */ +//SYM_REF2(prog_cnxn_assign_c, symbolic_variable, prog_data_source) + +/* any_symbolic_variable SENDTO data_sink */ +//SYM_REF2(prog_cnxn_sendto_c, symbolic_variable, prog_data_source) + +/* VAR_CONFIG instance_specific_init_list END_VAR */ +//SYM_REF2(instance_specific_initializations_c, instance_specific_init_list, unused) + +/* helper symbol for instance_specific_initializations */ +//SYM_LIST(instance_specific_init_list_c) + +/* resource_name '.' program_name '.' {fb_name '.'} + ((variable_name [location] ':' located_var_spec_init) | (fb_name ':' fb_initialization)) +*/ +//SYM_REF6(instance_specific_init_c, resource_name, program_name, any_fb_name_list, variable_name, location, initialization) + +/* helper symbol for instance_specific_init */ +/* function_block_type_name ':=' structure_initialization */ +//SYM_REF2(fb_initialization_c, function_block_type_name, structure_initialization) + + + +}; /* generate_c_configbody_c */ + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/generate_c_il.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/generate_c_il.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,1465 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * Conversion of il statements (i.e. IL code). + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the IL and ST + * code. + */ + + + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + +/* Returns the data type of an il_operand. + * + * Note that the il_operand may be a variable, in which case + * we return the type of the variable instance. + * The il_operand may also be a constant, in which case + * we return the data type of that constant. + * + * The variable instance may be a member of a structured variable, + * or an element in an array, or any combination of the two. + * + * The class constructor must be given the search scope + * (function, function block or program within which + * the possible il_operand variable instance was declared). + */ + +class search_il_operand_type_c { + + private: + search_varfb_instance_type_c search_varfb_instance_type; + search_constant_type_c search_constant_type; + + public: + search_il_operand_type_c(symbol_c *search_scope): search_varfb_instance_type(search_scope) {} + + public: + symbol_c *get_type(symbol_c *il_operand) { + symbol_c *res; + + /* We first assume that it is a constant... */ + res = search_constant_type.get_type(il_operand); + if (res != NULL) return res; + + /* Nope, now we assume it is a variable, and determine its type... */ + res = search_varfb_instance_type.get_type(il_operand); + if (NULL != res) return res; + + /* not found */ + return NULL; + } +}; + + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + + +/* A new class to ouput the il default variable to c++ code + * We use this class, inheriting from symbol_c, so it may be used + * as any other symbol_c object in the intermediate parse tree, + * more specifically, so it can be used as any other il operand. + * This makes the rest of the code much easier... + * + * Nevertheless, the basic visitor class visitor_c does not know + * how to visit this new il_default_variable_c class, so we have + * to extend that too. + * In reality extending the basic symbols doesn't quite work out + * as cleanly as desired (we need to use dynamic_cast in the + * accept method of the il_default_variable_c), but it is cleaner + * than the alternative... + */ +class il_default_variable_c; + +/* This visitor class is not really required, we could place the + * visit() method directly in genertae_cc_il_c, but doing it in + * a seperate class makes the architecture more evident... + */ +class il_default_variable_visitor_c { + public: + virtual void *visit(il_default_variable_c *symbol) = 0; + + virtual ~il_default_variable_visitor_c(void) {return;} +}; + + +/* A class to print out to the resulting C++ code + * the IL default variable name. + * + * It includes a reference to its name, + * and the data type of the data currently stored + * in this C++ variable... This is required because the + * C++ variable is a union, and we must know which member + * of the union top reference!! + * + * Note that we also need to keep track of the data type of + * the value currently being stored in the default variable. + * This is required so we can process parenthesis, + * + * e.g. : + * LD var1 + * AND ( + * LD var2 + * OR var3 + * ) + * + * Note that we only execute the 'AND (' operation when we come across + * the ')', i.e. once we have evaluated the result of the + * instructions inside the parenthesis. + * When we do execute the 'AND (' operation, we need to know the data type + * of the operand, which in this case is the result of the evaluation of the + * instruction list inside the parenthesis. We can only know this if we + * keep track of the data type currently stored in the default variable! + * + * We use the current_type inside the generate_c_il::default_variable_name variable + * to track this! + */ +class il_default_variable_c: public symbol_c { + public: + symbol_c *var_name; /* in principle, this should point to an indentifier_c */ + symbol_c *current_type; + + public: + il_default_variable_c(const char *var_name_str, symbol_c *current_type); + virtual void *accept(visitor_c &visitor); +}; + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + + + +class generate_c_il_c: public generate_c_typedecl_c, il_default_variable_visitor_c { + + private: + /* When compiling il code, it becomes necessary to determine the + * data type of il operands. To do this, we must first find the + * il operand's declaration, within the scope of the function block + * or function currently being processed. + * The following object does just that... + * This object instance will then later be called while the + * remaining il code is being handled. + */ + //search_il_operand_type_c *search_il_operand_type; + search_expression_type_c *search_expression_type; + + /* The initial value that should be given to the IL default variable + * imediately after a parenthesis is opened. + * This variable is only used to pass data from the + * il_expression_c visitor to the simple_instr_list_c visitor. + * + * e.g.: + * LD var1 + * AND ( var2 + * OR var3 + * ) + * + * In the above code sample, the line 'AND ( var2' constitutes + * an il_expression_c, where var2 should be loaded into the + * il default variable before continuing with the expression + * inside the parenthesis. + * Unfortunately, only the simple_instr_list_c may do the + * initial laoding of the var2 bariable following the parenthesis, + * so the il_expression_c visitor will have to pass 'var2' as a + * parameter to the simple_instr_list_c visitor. + * Ergo, the existance of the following parameter...! + */ + symbol_c *il_default_variable_init_value; + + /* Operand to the IL operation currently being processed... */ + /* These variables are used to pass data from the + * il_simple_operation_c and il_expression_c visitors + * to the il operator visitors (i.e. LD_operator_c, + * LDN_operator_c, ST_operator_c, STN_operator_c, ...) + */ + symbol_c *current_operand; + symbol_c *current_operand_type; + + /* Label to which the current IL jump operation should jump to... */ + /* This variable is used to pass data from the + * il_jump_operation_c visitor + * to the il jump operator visitors (i.e. JMP_operator_c, + * JMPC_operator_c, JMPCN_operator_c, ...) + */ + symbol_c *jump_label; + + /* The result of the comparison IL operations (GT, EQ, LT, ...) + * is a boolean variable. + * This class keeps track of the current data type stored in the + * il default variable. This is usually done by keeping a reference + * to the data type of the last operand. Nevertheless, in the case of + * the comparison IL operators, the data type of the result (a boolean) + * is not the data type of the operand. We therefore need an object + * of the boolean data type to keep as a reference of the current + * data type. + * The following object is it... + */ + bool_type_name_c bool_type; + + /* the data type of the IL default variable... */ + #define IL_DEFVAR_T VAR_LEADER "IL_DEFVAR_T" + /* The name of the IL default variable... */ + #define IL_DEFVAR VAR_LEADER "IL_DEFVAR" + /* The name of the variable used to pass the result of a + * parenthesised instruction list to the immediately preceding + * scope ... + */ + #define IL_DEFVAR_BACK VAR_LEADER "IL_DEFVAR_BACK" + il_default_variable_c default_variable_name; + il_default_variable_c default_variable_back_name; + + /* Some function calls in the body of functions or function blocks + * may leave some parameters to their default values, and + * ignore some output parameters of the function being called. + * Our conversion of ST functions to C++ does not contemplate that, + * i.e. each called function must get all it's input and output + * parameters set correctly. + * For input parameters we merely need to call the function with + * the apropriate default value, but for output parameters + * we must create temporary variables to hold the output value. + * + * We declare all the temporary output variables at the begining of + * the body of each function or function block, and use them as + * in function calls later on as they become necessary... + * Note that we cannot create these variables just before a function + * call, as the function call itself may be integrated within an + * expression, or another function call! + * + * The variables are declared in the exact same order in which they + * will be used later on during the function calls, which allows us + * to simply re-create the name that was used for the temporary variable + * instead of keeping it in some list. + * The names are recreated by the temp_var_name_factory, after reset() + * has been called! + * + * This function will genertae code similar to... + * + * INT __TMP_0 = 23; + * REAL __TMP_1 = 45.5; + * ... + */ + temp_var_name_c temp_var_name_factory; + + /* When calling a function block, we must first find it's type, + * by searching through the declarations of the variables currently + * in scope. + * This class does just that... + * A new class is instantiated whenever we begin generating the code + * for a function block type declaration, or a program declaration. + * This object instance will then later be called while the + * function block's or the program's body is being handled. + * + * Note that functions cannot contain calls to function blocks, + * so we do not create an object instance when handling + * a function declaration. + */ + search_fb_instance_decl_c *search_fb_instance_decl; + + + public: + generate_c_il_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) + : generate_c_typedecl_c(s4o_ptr), + default_variable_name(IL_DEFVAR, NULL), + default_variable_back_name(IL_DEFVAR_BACK, NULL) + { + //search_il_operand_type = new search_il_operand_type_c(scope); + search_expression_type = new search_expression_type_c(scope); + search_fb_instance_decl = new search_fb_instance_decl_c(scope); + current_operand = NULL; + current_operand_type = NULL; + il_default_variable_init_value = NULL; + this->set_variable_prefix(variable_prefix); + } + + virtual ~generate_c_il_c(void) { + delete search_fb_instance_decl; + //delete search_il_operand_type; + delete search_expression_type; + } + + void generate(instruction_list_c *il) { + generate_c_tempvardecl_c generate_c_tempvardecl(&s4o); + generate_c_tempvardecl.generate(il, &temp_var_name_factory); + il->accept(*this); + } + + /* Declare the backup to the default variable, that will store the result + * of the IL operations executed inside a parenthesis... + */ + void declare_backup_variable(void) { + s4o.print(s4o.indent_spaces); + s4o.print(IL_DEFVAR_T); + s4o.print(" "); + print_backup_variable(); + s4o.print(";\n"); + } + + void print_backup_variable(void) { + this->default_variable_back_name.accept(*this); + } + + private: + /* A helper function... */ + /* + bool is_bool_type(symbol_c *type_symbol) { + return (NULL != dynamic_cast(type_symbol)); + } + */ + + /* A helper function... */ + void *XXX_operator(symbol_c *lo, const char *op, symbol_c *ro) { + if ((NULL == lo) || (NULL == ro)) ERROR; + if (NULL == op) ERROR; + + lo->accept(*this); + s4o.print(op); + ro->accept(*this); + return NULL; + } + + /* A helper function... */ + void *XXX_function(const char *func, symbol_c *lo, symbol_c *ro) { + if ((NULL == lo) || (NULL == ro)) ERROR; + if (NULL == func) ERROR; + + lo->accept(*this); + s4o.print(" = "); + s4o.print(func); + s4o.print("("); + lo->accept(*this); + s4o.print(", "); + ro->accept(*this); + s4o.print(")"); + return NULL; + } + + /* A helper function... */ + void *XXX_CAL_operator(const char *param_name, symbol_c *fb_name) { + if (NULL == fb_name) ERROR; + symbolic_variable_c *sv = dynamic_cast(fb_name); + if (NULL == sv) ERROR; + identifier_c *id = dynamic_cast(sv->var_name); + if (NULL == id) ERROR; + + identifier_c param(param_name); + + //SYM_REF3(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list) + il_param_assignment_c il_param_assignment(¶m, &this->default_variable_name, NULL); + // SYM_LIST(il_param_list_c) + il_param_list_c il_param_list; + il_param_list.add_element(&il_param_assignment); + CAL_operator_c CAL_operator; + // SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list) + il_fb_call_c il_fb_call(&CAL_operator, id, NULL, &il_param_list); + + il_fb_call.accept(*this); + return NULL; + } + + /* A helper function... */ + void *CMP_operator(symbol_c *o, const char *operation) { + if (NULL == o) ERROR; + if (NULL == this->default_variable_name.current_type) ERROR; + + symbol_c *backup = this->default_variable_name.current_type; + this->default_variable_name.current_type = &(this->bool_type); + this->default_variable_name.accept(*this); + this->default_variable_name.current_type = backup; + + s4o.print(" = "); + s4o.print(operation); + this->default_variable_name.current_type->accept(*this); + s4o.print("(2, "); + this->default_variable_name.accept(*this); + s4o.print(", "); + o->accept(*this); + s4o.print(")"); + + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = &(this->bool_type); + return NULL; + } + + + /* A helper function... */ + void C_modifier(void) { + if (search_expression_type->is_bool_type(default_variable_name.current_type)) { + s4o.print("if ("); + this->default_variable_name.accept(*this); + s4o.print(") "); + } + else {ERROR;} + } + + /* A helper function... */ + void CN_modifier(void) { + if (search_expression_type->is_bool_type(default_variable_name.current_type)) { + s4o.print("if (!"); + this->default_variable_name.accept(*this); + s4o.print(") "); + } + else {ERROR;} + } + + +public: +void *visit(il_default_variable_c *symbol) { + //s4o.print("il_default_variable_c VISITOR!!\n"); + symbol->var_name->accept(*this); + if (NULL != symbol->current_type) { + s4o.print("."); + symbol->current_type->accept(*this); + s4o.print("var"); + } + return NULL; +} + + +private: + +/********************************************/ +/* B.1.4.1 Directly Represented Variables */ +/********************************************/ +// direct_variable: direct_variable_token {$$ = new direct_variable_c($1);}; +void *visit(direct_variable_c *symbol) { + TRACE("direct_variable_c"); + /* Do not use print_token() as it will change everything into uppercase */ + if (strlen(symbol->value) == 0) ERROR; + s4o.print("*("); + this->print_variable_prefix(); + s4o.printlocation(symbol->value + 1); + s4o.print(")"); + return NULL; +} + +/****************************************/ +/* B.2 - Language IL (Instruction List) */ +/****************************************/ + +/***********************************/ +/* B 2.1 Instructions and Operands */ +/***********************************/ + +/* please see the comment before the RET_operator_c visitor for details... */ +#define END_LABEL VAR_LEADER "end" + +/*| instruction_list il_instruction */ +void *visit(instruction_list_c *symbol) { + + /* Declare the backup to the default variable, that will store the result + * of the IL operations executed inside a parenthesis... + */ + declare_backup_variable(); + + /* Declare the default variable, that will store the result of the IL operations... */ + s4o.print(s4o.indent_spaces); + s4o.print(IL_DEFVAR_T); + s4o.print(" "); + this->default_variable_name.accept(*this); + s4o.print(";\n\n"); + + print_list(symbol, s4o.indent_spaces, ";\n" + s4o.indent_spaces, ";\n"); + + /* write the label marking the end of the code block */ + /* please see the comment before the RET_operator_c visitor for details... */ + s4o.print("\n"); + s4o.print(s4o.indent_spaces); + s4o.print(END_LABEL); + s4o.print(":\n"); + s4o.indent_right(); + /* since every label must be followed by at least one statement, and + * only the functions will introduce the return statement after this label, + * function blocks written in IL would result in invalid C++ code. + * To work around this we introduce the equivalent of a 'nop' operation + * to humour the compiler... + */ + s4o.print(s4o.indent_spaces); + s4o.print("/* to humour the compiler, we insert a nop */\n"); + s4o.print(s4o.indent_spaces); + this->default_variable_name.accept(*this); + s4o.print(" = "); + this->default_variable_name.accept(*this); + s4o.print(";\n"); + s4o.indent_left(); + + return NULL; +} + + +/* | label ':' [il_incomplete_instruction] eol_list */ +// SYM_REF2(il_instruction_c, label, il_instruction) +void *visit(il_instruction_c *symbol) { + if (NULL != symbol->label) { + symbol->label->accept(*this); + s4o.print(":\n"); + s4o.print(s4o.indent_spaces); + } + symbol->il_instruction->accept(*this); + return NULL; +} + +/* | il_simple_operator [il_operand] */ +//SYM_REF2(il_simple_operation_c, il_simple_operator, il_operand) +void *visit(il_simple_operation_c *symbol) { + this->current_operand = symbol->il_operand; + if (NULL == this->current_operand) { + this->current_operand_type = NULL; + } else { + this->current_operand_type = search_expression_type->get_type(this->current_operand); + if (NULL == this->current_operand_type) ERROR; + } + + symbol->il_simple_operator->accept(*this); + + this->current_operand = NULL; + this->current_operand_type = NULL; + return NULL; +} + + +/* | function_name [il_operand_list] */ +// SYM_REF2(il_function_call_c, function_name, il_operand_list) +void *visit(il_function_call_c *symbol) { + function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name); + + if (f_decl == function_symtable.end_value()) { + /* should never occur. The function being called MUST be in the symtable... */ + function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name); + if (current_function_type == function_none) ERROR; + + symbol_c *param_data_type = default_variable_name.current_type; + symbol_c *return_data_type = (symbol_c *)search_expression_type->compute_standard_function_il(symbol, param_data_type); + if (NULL == return_data_type) ERROR; + + default_variable_name.current_type = return_data_type; + this->default_variable_name.accept(*this); + default_variable_name.current_type = param_data_type; + s4o.print(" = "); + + function_call_param_iterator_c function_call_param_iterator(symbol); + + int nb_param = 1; + if (symbol->il_operand_list != NULL) + nb_param += ((list_c *)symbol->il_operand_list)->n; + +#include "il_code_gen.c" + +#if 0 + for(int current_param = 0; current_param < nb_param; current_param++) { + symbol_c *param_value; + if (current_param == 0) + param_value = &this->default_variable_name; + else { + symbol_c *param_name = NULL; + switch (current_function_type) { + default: ERROR; + } + + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(param_name); + delete param_name; + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + + if (param_value == NULL) ERROR; + } + + switch (current_function_type) { + case (function_sqrt): + if (current_param == 0) { + s4o.print("sqrt("); + param_value->accept(*this); + s4o.print(")"); + } + else ERROR; + break; + default: ERROR; + } + } /* for(...) */ +#endif + + /* the data type returned by the function, and stored in the il default variable... */ + default_variable_name.current_type = return_data_type; + } + else { + /* determine the base data type returned by the function being called... */ + search_base_type_c search_base_type; + symbol_c *return_data_type = (symbol_c *)f_decl->type_name->accept(search_base_type); + symbol_c *param_data_type = default_variable_name.current_type; + if (NULL == return_data_type) ERROR; + + default_variable_name.current_type = return_data_type; + this->default_variable_name.accept(*this); + default_variable_name.current_type = param_data_type; + s4o.print(" = "); + + symbol->function_name->accept(*this); + s4o.print("("); + + /* loop through each function parameter, find the value we should pass + * to it, and then output the c equivalent... + */ + + function_param_iterator_c fp_iterator(f_decl); + identifier_c *param_name; + function_call_param_iterator_c function_call_param_iterator(symbol); + for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { + if (i != 1) + s4o.print(", "); + + symbol_c *param_type = fp_iterator.param_type(); + if (param_type == NULL) ERROR; + + function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); + + + symbol_c *param_value = NULL; + + /* if it is the first parameter, semantics specifies that we should + * get the value off the IL default variable! + */ + if (1 == i) + param_value = &this->default_variable_name; + + /* Get the value from a foo( = ) style call */ + /* NOTE: the following line of code is not required in this case, but it doesn't + * harm to leave it in, as in the case of a non-formal syntax function call, + * it will always return NULL. + * We leave it in in case we later decide to merge this part of the code together + * with the function calling code in generate_c_st_c, which does require + * the following line... + */ + if (param_value == NULL) + param_value = function_call_param_iterator.search(param_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + + switch (param_direction) { + case function_param_iterator_c::direction_in: + if (param_value == NULL) { + /* No value given for parameter, so we must use the default... */ + /* First check whether default value specified in function declaration...*/ + param_value = fp_iterator.default_value(); + } + if (param_value == NULL) { + /* If not, get the default value of this variable's type */ + param_value = (symbol_c *)param_type->accept(*type_initial_value_c::instance()); + } + if (param_value == NULL) ERROR; + param_value->accept(*this); + break; + case function_param_iterator_c::direction_out: + case function_param_iterator_c::direction_inout: + if (param_value == NULL) { + /* no parameter value given, so we pass a previously declared temporary variable. */ + std::string *temp_var_name = temp_var_name_factory.new_name(); + s4o.print(*temp_var_name); + delete temp_var_name; + } else { + param_value->accept(*this); + } + break; + case function_param_iterator_c::direction_extref: + /* TODO! */ + ERROR; + break; + } /* switch */ + } /* for(...) */ + + s4o.print(")"); + /* the data type returned by the function, and stored in the il default variable... */ + default_variable_name.current_type = return_data_type; + } + + return NULL; +} + + +/* | il_expr_operator '(' [il_operand] eol_list [simple_instr_list] ')' */ +//SYM_REF4(il_expression_c, il_expr_operator, il_operand, simple_instr_list, unused) +void *visit(il_expression_c *symbol) { + /* We will be recursevely interpreting an instruction list, + * so we store a backup of the data type of the value currently stored + * in the default variable, and set the current data type to NULL + */ + symbol_c *old_current_default_variable_data_type = this->default_variable_name.current_type; + this->default_variable_name.current_type = NULL; + + /* Pass the symbol->il_operand to the simple_instr_list visitor + * using the il_default_variable_init_value parameter... + * Note that the simple_instr_list_c visitor will set this parameter + * to NULL as soon as it does not require it any longer, + * so we don't do it here again after the + * symbol->simple_instr_list->accept(*this); + * returns... + */ + this->il_default_variable_init_value = symbol->il_operand; + + /* Now do the parenthesised instructions... */ + /* NOTE: the following code line will get the variable + * this->default_variable_name.current_type updated! + */ + symbol->simple_instr_list->accept(*this); + + /* Now do the operation, using the previous result! */ + /* NOTE: The result of the previous instruction list will be stored + * in a variable named IL_DEFVAR_BACK. This is done in the visitor + * to instruction_list_c objects... + */ + this->current_operand = &(this->default_variable_back_name); + this->current_operand_type = this->default_variable_back_name.current_type; + + this->default_variable_name.current_type = old_current_default_variable_data_type; + if (NULL == this->current_operand_type) ERROR; + + symbol->il_expr_operator->accept(*this); + + this->current_operand = NULL; + this->current_operand_type = NULL; + this->default_variable_back_name.current_type = NULL; + return NULL; +} + +/* il_jump_operator label */ +// SYM_REF2(il_jump_operation_c, il_jump_operator, label) +void *visit(il_jump_operation_c *symbol) { + /* Pass the symbol->label to the il_jump_operation visitor + * using the jump_label parameter... + */ + this->jump_label = symbol->label; + symbol->il_jump_operator->accept(*this); + this->jump_label = NULL; + + return NULL; +} + +/* il_call_operator prev_declared_fb_name + * | il_call_operator prev_declared_fb_name '(' ')' + * | il_call_operator prev_declared_fb_name '(' eol_list ')' + * | il_call_operator prev_declared_fb_name '(' il_operand_list ')' + * | il_call_operator prev_declared_fb_name '(' eol_list il_param_list ')' + */ +// SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list) +void *visit(il_fb_call_c *symbol) { + symbol->il_call_operator->accept(*this); + s4o.print("{\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + + /* first figure out what is the name of the function block type of the function block being called... */ + symbol_c *function_block_type_name = this->search_fb_instance_decl->get_type_name(symbol->fb_name); + /* should never occur. The function block instance MUST have been declared... */ + if (function_block_type_name == NULL) ERROR; + + /* Now find the declaration of the function block type being called... */ + function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(function_block_type_name); + /* should never occur. The function block type being called MUST be in the symtable... */ + if (fb_decl == function_block_type_symtable.end_value()) ERROR; + + /* loop through each function block parameter, find the value we should pass + * to it, and then output the c equivalent... + */ + function_param_iterator_c fp_iterator(fb_decl); + identifier_c *param_name; + function_call_param_iterator_c function_call_param_iterator(symbol); + for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { + function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); + + /* Get the value from a foo( = ) style call */ + symbol_c *param_value = function_call_param_iterator.search(param_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + + /* now output the value assignment */ + if (param_value != NULL) + if ((param_direction == function_param_iterator_c::direction_in) || + (param_direction == function_param_iterator_c::direction_inout)) { + symbol->fb_name->accept(*this); + s4o.print("."); + param_name->accept(*this); + s4o.print(" = "); + param_value->accept(*this); + s4o.print(";\n" + s4o.indent_spaces); + } + } /* for(...) */ + + /* now call the function... */ + function_block_type_name->accept(*this); + s4o.print(FB_FUNCTION_SUFFIX); + s4o.print("(&"); + symbol->fb_name->accept(*this); + s4o.print(")"); + + /* loop through each function parameter, find the variable to which + * we should atribute the value of all output or inoutput parameters. + */ + fp_iterator.reset(); + function_call_param_iterator.reset(); + for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { + function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); + + /* Get the value from a foo( = ) style call */ + symbol_c *param_value = function_call_param_iterator.search(param_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + + /* now output the value assignment */ + if (param_value != NULL) + if ((param_direction == function_param_iterator_c::direction_out) || + (param_direction == function_param_iterator_c::direction_inout)) { + s4o.print(";\n"+ s4o.indent_spaces); + param_value->accept(*this); + s4o.print(" = "); + symbol->fb_name->accept(*this); + s4o.print("."); + param_name->accept(*this); + } + } /* for(...) */ + + s4o.print(";\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces); + s4o.print("}"); + + return NULL; +} + + + +/* | function_name '(' eol_list [il_param_list] ')' */ +// SYM_REF2(il_formal_funct_call_c, function_name, il_param_list) +void *visit(il_formal_funct_call_c *symbol) { + function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name); + + if (f_decl == function_symtable.end_value()) + /* should never occur. The function being called MUST be in the symtable... */ + ERROR; + + symbol->function_name->accept(*this); + s4o.print("("); + + /* loop through each function parameter, find the value we should pass + * to it, and then output the c equivalent... + */ + + function_param_iterator_c fp_iterator(f_decl); + identifier_c *param_name; + function_call_param_iterator_c function_call_param_iterator(symbol); + for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { + if (i != 1) + s4o.print(", "); + + symbol_c *param_type = fp_iterator.param_type(); + if (param_type == NULL) ERROR; + + function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); + + + symbol_c *param_value = NULL; + + /* Get the value from a foo( = ) style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.search(param_name); + + /* Get the value from a foo() style call */ + /* NOTE: the following line of code is not required in this case, but it doesn't + * harm to leave it in, as in the case of a formal syntax function call, + * it will always return NULL. + * We leave it in in case we later decide to merge this part of the code together + * with the function calling code in generate_c_st_c, which does require + * the following line... + */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + + switch (param_direction) { + case function_param_iterator_c::direction_in: + if (param_value == NULL) { + /* No value given for parameter, so we must use the default... */ + /* First check whether default value specified in function declaration...*/ + param_value = fp_iterator.default_value(); + } + if (param_value == NULL) { + /* If not, get the default value of this variable's type */ + param_value = (symbol_c *)param_type->accept(*type_initial_value_c::instance()); + } + if (param_value == NULL) ERROR; + param_value->accept(*this); + break; + case function_param_iterator_c::direction_out: + case function_param_iterator_c::direction_inout: + if (param_value == NULL) { + /* no parameter value given, so we pass a previously declared temporary variable. */ + std::string *temp_var_name = temp_var_name_factory.new_name(); + s4o.print(*temp_var_name); + delete temp_var_name; + } else { + param_value->accept(*this); + } + break; + case function_param_iterator_c::direction_extref: + /* TODO! */ + ERROR; + break; + } /* switch */ + } /* for(...) */ + + // symbol->parameter_assignment->accept(*this); + s4o.print(")"); + return NULL; +} + + +/* | il_operand_list ',' il_operand */ +// SYM_LIST(il_operand_list_c) +void *visit(il_operand_list_c *symbol) {ERROR; return NULL;} // should never get called! + + +/* | simple_instr_list il_simple_instruction */ +// SYM_LIST(simple_instr_list_c) +void *visit(simple_instr_list_c *symbol) { + /* A simple_instr_list_c is used to store a list of il operations + * being done within parenthesis... + * + * e.g.: + * LD var1 + * AND ( var2 + * OR var3 + * OR var4 + * ) + * + * This will be converted to C++ by defining a new scope + * with a new il default variable, and executing the il operands + * within this new scope. + * At the end of the scope the result, i.e. the value currently stored + * in the il default variable is copied to the variable used to take this + * value to the outside scope... + * + * The above example will result in the following C++ code: + * {__IL_DEFVAR_T __IL_DEFVAR_BACK; + * __IL_DEFVAR_T __IL_DEFVAR; + * + * __IL_DEFVAR.INTvar = var1; + * { + * __IL_DEFVAR_T __IL_DEFVAR; + * + * __IL_DEFVAR.INTvar = var2; + * __IL_DEFVAR.INTvar |= var3; + * __IL_DEFVAR.INTvar |= var4; + * + * __IL_DEFVAR_BACK = __IL_DEFVAR; + * } + * __IL_DEFVAR.INTvar &= __IL_DEFVAR_BACK.INTvar; + * + * } + * + * The intial value of the il default variable (in the above + * example 'var2') is passed to this simple_instr_list_c visitor + * using the il_default_variable_init_value parameter. + * Since it is possible to have parenthesis inside other parenthesis + * recursively, we reset the il_default_variable_init_value to NULL + * as soon as we no longer require it, as it may be used once again + * in the line + * print_list(symbol, s4o.indent_spaces, ";\n" + s4o.indent_spaces, ";\n"); + * + */ + + /* Declare the default variable, that will store the result of the IL operations... */ + s4o.print("{\n"); + s4o.indent_right(); + + s4o.print(s4o.indent_spaces); + s4o.print(IL_DEFVAR_T); + s4o.print(" "); + this->default_variable_name.accept(*this); + s4o.print(";\n\n"); + + /* Check whether we should initiliase the il default variable... */ + if (NULL != this->il_default_variable_init_value) { + /* Yes, we must... */ + /* We will do it by instatiating a LD operator, and having this + * same generate_c_il_c class visiting it! + */ + LD_operator_c ld_oper; + il_simple_operation_c il_simple_oper(&ld_oper, this->il_default_variable_init_value); + + s4o.print(s4o.indent_spaces); + il_simple_oper.accept(*this); + s4o.print(";\n"); + } + + /* this parameter no longer required... */ + this->il_default_variable_init_value = NULL; + + print_list(symbol, s4o.indent_spaces, ";\n" + s4o.indent_spaces, ";\n"); + + /* copy the result in the default variable to the variable + * used to pass the data out to the scope enclosing + * the current scope! + * + * We also need to update the data type currently stored within + * the variable used to pass the data to the outside scope... + */ + this->default_variable_back_name.current_type = this->default_variable_name.current_type; + s4o.print("\n"); + s4o.print(s4o.indent_spaces); + this->default_variable_back_name.accept(*this); + s4o.print(" = "); + this->default_variable_name.accept(*this); + s4o.print(";\n"); + + s4o.indent_left(); + s4o.print(s4o.indent_spaces); + s4o.print("}\n"); + s4o.print(s4o.indent_spaces); + return NULL; +} + +/* | il_initial_param_list il_param_instruction */ +// SYM_LIST(il_param_list_c) +void *visit(il_param_list_c *symbol) {ERROR; return NULL;} // should never get called! + +/* il_assign_operator il_operand + * | il_assign_operator '(' eol_list simple_instr_list ')' + */ +// SYM_REF4(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list, unused) +void *visit(il_param_assignment_c *symbol) {ERROR; return NULL;} // should never get called! + +/* il_assign_out_operator variable */ +// SYM_REF2(il_param_out_assignment_c, il_assign_out_operator, variable); +void *visit(il_param_out_assignment_c *symbol) {ERROR; return NULL;} // should never get called! + +/*******************/ +/* B 2.2 Operators */ +/*******************/ + +void *visit(LD_operator_c *symbol) { + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + XXX_operator(&(this->default_variable_name), " = ", this->current_operand); + return NULL; +} + +void *visit(LDN_operator_c *symbol) { + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + XXX_operator(&(this->default_variable_name), + search_expression_type->is_bool_type(this->current_operand_type)?" = !":" = ~", + this->current_operand); + return NULL; +} + +void *visit(ST_operator_c *symbol) { + XXX_operator(this->current_operand, " = ",&(this->default_variable_name)); + /* the data type resulting from this operation is unchamged. */ + return NULL; +} + +void *visit(STN_operator_c *symbol) { + XXX_operator(this->current_operand, + search_expression_type->is_bool_type(this->current_operand_type)?" = !":" = ~", + &(this->default_variable_name)); + /* the data type resulting from this operation is unchamged. */ + return NULL; +} + +void *visit(NOT_operator_c *symbol) { + if ((NULL != this->current_operand) || (NULL != this->current_operand_type)) ERROR; + XXX_operator(&(this->default_variable_name), + search_expression_type->is_bool_type(this->default_variable_name.current_type)?" = !":" = ~", + &(this->default_variable_name)); + /* the data type resulting from this operation is unchanged. */ + return NULL; +} + +void *visit(S_operator_c *symbol) { + if ((NULL == this->current_operand) || (NULL == this->current_operand_type)) ERROR; + + C_modifier(); + this->current_operand->accept(*this); + s4o.print(search_expression_type->is_bool_type(this->current_operand_type)?" = true":" = 1"); + /* the data type resulting from this operation is unchanged! */ + return NULL; +} + +void *visit(R_operator_c *symbol) { + if ((NULL == this->current_operand) || (NULL == this->current_operand_type)) ERROR; + + C_modifier(); + this->current_operand->accept(*this); + s4o.print(search_expression_type->is_bool_type(this->current_operand_type)?" = false":" = 0"); + /* the data type resulting from this operation is unchanged! */ + return NULL; +} + +void *visit(S1_operator_c *symbol) {return XXX_CAL_operator("S1", this->current_operand);} +void *visit(R1_operator_c *symbol) {return XXX_CAL_operator("R1", this->current_operand);} +void *visit(CLK_operator_c *symbol) {return XXX_CAL_operator("CLK", this->current_operand);} +void *visit(CU_operator_c *symbol) {return XXX_CAL_operator("CU", this->current_operand);} +void *visit(CD_operator_c *symbol) {return XXX_CAL_operator("CD", this->current_operand);} +void *visit(PV_operator_c *symbol) {return XXX_CAL_operator("PV", this->current_operand);} +void *visit(IN_operator_c *symbol) {return XXX_CAL_operator("IN", this->current_operand);} +void *visit(PT_operator_c *symbol) {return XXX_CAL_operator("PT", this->current_operand);} + +void *visit(AND_operator_c *symbol) { + if (search_expression_type->is_binary_type(this->default_variable_name.current_type) && + search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { + XXX_operator(&(this->default_variable_name), " &= ", this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + } + else {ERROR;} + return NULL; +} + +void *visit(OR_operator_c *symbol) { + if (search_expression_type->is_binary_type(this->default_variable_name.current_type) && + search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { + XXX_operator(&(this->default_variable_name), " |= ", this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + } + else {ERROR;} + return NULL; +} + +void *visit(XOR_operator_c *symbol) { + if (search_expression_type->is_binary_type(this->default_variable_name.current_type) && + search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { + // '^' is a bit by bit exclusive OR !! Also seems to work with boolean types! + XXX_operator(&(this->default_variable_name), " ^= ", this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + } + else {ERROR;} + return NULL; +} + +void *visit(ANDN_operator_c *symbol) { + if (search_expression_type->is_binary_type(this->default_variable_name.current_type) && + search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { + XXX_operator(&(this->default_variable_name), + search_expression_type->is_bool_type(this->current_operand_type)?" &= !":" &= ~", + this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + } + else {ERROR;} + return NULL; +} + +void *visit(ORN_operator_c *symbol) { + if (search_expression_type->is_binary_type(this->default_variable_name.current_type) && + search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { + XXX_operator(&(this->default_variable_name), + search_expression_type->is_bool_type(this->current_operand_type)?" |= !":" |= ~", + this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + } + else {ERROR;} + return NULL; +} + +void *visit(XORN_operator_c *symbol) { + if (search_expression_type->is_binary_type(this->default_variable_name.current_type) && + search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { + XXX_operator(&(this->default_variable_name), + // bit by bit exclusive OR !! Also seems to work with boolean types! + search_expression_type->is_bool_type(this->current_operand_type)?" ^= !":" ^= ~", + this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + } + else {ERROR;} + return NULL; +} + +void *visit(ADD_operator_c *symbol) { + if (search_expression_type->is_time_type(this->default_variable_name.current_type) && + search_expression_type->is_time_type(this->current_operand_type)) { + XXX_function("__time_add", &(this->default_variable_name), this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + return NULL; + } + if (search_expression_type->is_num_type(this->default_variable_name.current_type) && + search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { + XXX_operator(&(this->default_variable_name), " += ", this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + return NULL; + } + ERROR; + return NULL; +} + +void *visit(SUB_operator_c *symbol) { + if (search_expression_type->is_time_type(this->default_variable_name.current_type) && + search_expression_type->is_time_type(this->current_operand_type)) { + XXX_function("__time_sub", &(this->default_variable_name), this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + return NULL; + } + if (search_expression_type->is_num_type(this->default_variable_name.current_type) && + search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { + XXX_operator(&(this->default_variable_name), " -= ", this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + return NULL; + } + ERROR; + return NULL; +} + +void *visit(MUL_operator_c *symbol) { + if (search_expression_type->is_time_type(this->default_variable_name.current_type) && + search_expression_type->is_integer_type(this->current_operand_type)) { + XXX_function("__time_mul", &(this->default_variable_name), this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + return NULL; + } + if (search_expression_type->is_num_type(this->default_variable_name.current_type) && + search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { + XXX_operator(&(this->default_variable_name), " *= ", this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + return NULL; + } + ERROR; + return NULL; +} + +void *visit(DIV_operator_c *symbol) { + if (search_expression_type->is_num_type(this->default_variable_name.current_type) && + search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { + XXX_operator(&(this->default_variable_name), " /= ", this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + } + else {ERROR;} + return NULL; +} + +void *visit(MOD_operator_c *symbol) { + if (search_expression_type->is_num_type(this->default_variable_name.current_type) && + search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { + XXX_operator(&(this->default_variable_name), " %= ", this->current_operand); + /* the data type resulting from this operation... */ + this->default_variable_name.current_type = this->current_operand_type; + } + else {ERROR;} + return NULL; +} + +void *visit(GT_operator_c *symbol) { + return CMP_operator(this->current_operand, "__gt_"); +} + +void *visit(GE_operator_c *symbol) { + return CMP_operator(this->current_operand, "__ge_"); +} + +void *visit(EQ_operator_c *symbol) { + return CMP_operator(this->current_operand, "__eq_"); +} + +void *visit(LT_operator_c *symbol) { + return CMP_operator(this->current_operand, "__lt_"); +} + +void *visit(LE_operator_c *symbol) { + return CMP_operator(this->current_operand, "__le_"); +} + +void *visit(NE_operator_c *symbol) { + return CMP_operator(this->current_operand, "__ne_"); +} + + +//SYM_REF0(CAL_operator_c) +// This method will be called from within the il_fb_call_c visitor method +void *visit(CAL_operator_c *symbol) {return NULL;} + +//SYM_REF0(CALC_operator_c) +// This method will be called from within the il_fb_call_c visitor method +void *visit(CALC_operator_c *symbol) {C_modifier(); return NULL;} + +//SYM_REF0(CALCN_operator_c) +// This method will be called from within the il_fb_call_c visitor method +void *visit(CALCN_operator_c *symbol) {CN_modifier(); return NULL;} + +/* NOTE: The semantics of the RET operator requires us to return a value + * if the IL code is inside a function, but simply return no value if + * the IL code is inside a function block or program! + * Nevertheless, it is the generate_c_c class itself that + * introduces the 'reaturn ' into the c++ code at the end + * of every function. This class does not know whether the IL code + * is inside a function or a function block. + * We work around this by jumping to the end of the code, + * that will be marked by the END_LABEL label in the + * instruction_list_c visitor... + */ +// SYM_REF0(RET_operator_c) +void *visit(RET_operator_c *symbol) { + s4o.print("goto ");s4o.print(END_LABEL); + return NULL; +} + +// SYM_REF0(RETC_operator_c) +void *visit(RETC_operator_c *symbol) { + C_modifier(); + s4o.print("goto ");s4o.print(END_LABEL); + return NULL; +} + +// SYM_REF0(RETCN_operator_c) +void *visit(RETCN_operator_c *symbol) { + CN_modifier(); + s4o.print("goto ");s4o.print(END_LABEL); + return NULL; +} + +//SYM_REF0(JMP_operator_c) +void *visit(JMP_operator_c *symbol) { + if (NULL == this->jump_label) ERROR; + + s4o.print("goto "); + this->jump_label->accept(*this); + /* the data type resulting from this operation is unchanged! */ + return NULL; +} + +// SYM_REF0(JMPC_operator_c) +void *visit(JMPC_operator_c *symbol) { + if (NULL == this->jump_label) ERROR; + + C_modifier(); + s4o.print("goto "); + this->jump_label->accept(*this); + /* the data type resulting from this operation is unchanged! */ + return NULL; +} + +// SYM_REF0(JMPCN_operator_c) +void *visit(JMPCN_operator_c *symbol) { + if (NULL == this->jump_label) ERROR; + + CN_modifier(); + s4o.print("goto "); + this->jump_label->accept(*this); + /* the data type resulting from this operation is unchanged! */ + return NULL; +} + +#if 0 +/*| [NOT] any_identifier SENDTO */ +SYM_REF2(il_assign_out_operator_c, option, variable_name) +#endif + +}; /* generate_c_il_c */ + + + + + + + + + +/* The implementation of the single visit() member function + * of il_default_variable_c. + * It can only come after the full declaration of + * generate_c_il_c. Since we define and declare + * generate_c_il_c simultaneously, it can only come + * after the definition... + */ +void *il_default_variable_c::accept(visitor_c &visitor) { + /* An ugly hack!! */ + /* This is required because we need to over-ride the base + * accept(visitor_c &) method of the class symbol_c, + * so this method may be called through a symbol_c * + * reference! + * + * But, the visitor_c does not include a visitor to + * an il_default_variable_c, which means that we couldn't + * simply call visitor.visit(this); + * + * We therefore need to use the dynamic_cast hack!! + * + * Note too that we can't cast a visitor_c to a + * il_default_variable_visitor_c, since they are not related. + * Nor may the il_default_variable_visitor_c inherit from + * visitor_c, because then generate_c_il_c would contain + * two visitor_c base classes, one each through + * il_default_variable_visitor_c and generate_c_type_c + * + * We could use virtual inheritance of the visitor_c, but it + * would probably create more problems than it is worth! + */ + generate_c_il_c *v; + v = dynamic_cast(&visitor); + if (v == NULL) ERROR; + + return v->visit(this); +} + + + + +il_default_variable_c::il_default_variable_c(const char *var_name_str, symbol_c *current_type) { + if (NULL == var_name_str) ERROR; + /* Note: current_type may start off with NULL */ + + this->var_name = new identifier_c(var_name_str); + if (NULL == this->var_name) ERROR; + + this->current_type = current_type; +} diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/generate_c_sfc.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/generate_c_sfc.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,736 @@ +/* + * (c) 2007 Mario de Sousa, Laurent Bessard + * + * 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) + * + */ + + +/* + * Conversion of sfc networks (i.e. SFC code). + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the SFC, IL and ST + * code. + */ + +#include + +typedef struct +{ + transition_c *symbol; + int priority; + int index; +} TRANSITION; + + + + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + +class generate_c_sfc_elements_c: public generate_c_base_c { + + public: + typedef enum { + transitionlist_sg, + transitiontest_sg, + stepset_sg, + stepreset_sg, + actionassociation_sg, + actionbody_sg + } sfcgeneration_t; + + private: + generate_c_il_c *generate_c_il; + generate_c_st_c *generate_c_st; + generate_c_SFC_IL_ST_c *generate_c_code; + search_var_instance_decl_c *search_var_instance_decl; + + int transition_number; + std::list transition_list; + + symbol_c *current_step; + symbol_c *current_action; + + sfcgeneration_t wanted_sfcgeneration; + + public: + generate_c_sfc_elements_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) + : generate_c_base_c(s4o_ptr) { + generate_c_il = new generate_c_il_c(s4o_ptr, scope, variable_prefix); + generate_c_st = new generate_c_st_c(s4o_ptr, scope, variable_prefix); + generate_c_code = new generate_c_SFC_IL_ST_c(s4o_ptr, scope, variable_prefix); + search_var_instance_decl = new search_var_instance_decl_c(scope); + this->set_variable_prefix(variable_prefix); + } + + ~generate_c_sfc_elements_c(void) { + delete generate_c_il; + delete generate_c_st; + delete generate_c_code; + delete search_var_instance_decl; + } + + void reset_transition_number(void) {transition_number = 0;} + + void generate(symbol_c *symbol, sfcgeneration_t generation_type) { + wanted_sfcgeneration = generation_type; + switch (wanted_sfcgeneration) { + case transitiontest_sg: + { + std::list::iterator pt; + for(pt = transition_list.begin(); pt != transition_list.end(); pt++) { + transition_number = pt->index; + pt->symbol->accept(*this); + } + } + break; + default: + symbol->accept(*this); + break; + } + } + + void print_step_argument(symbol_c *step_name, const char* argument) { + print_variable_prefix(); + s4o.print("step_list["); + s4o.print(SFC_STEP_ACTION_PREFIX); + step_name->accept(*this); + s4o.print("]."); + s4o.print(argument); + } + + void print_action_argument(symbol_c *action_name, const char* argument) { + print_variable_prefix(); + s4o.print("action_list["); + s4o.print(SFC_STEP_ACTION_PREFIX); + action_name->accept(*this); + s4o.print("]."); + s4o.print(argument); + } + + void print_transition_number(void) { + char str[10]; + sprintf(str, "%d", transition_number); + s4o.print(str); + } + + void print_reset_step(symbol_c *step_name) { + s4o.print(s4o.indent_spaces); + print_step_argument(step_name, "state"); + s4o.print(" = 0;\n"); + } + + void print_set_step(symbol_c *step_name) { + s4o.print(s4o.indent_spaces); + print_step_argument(step_name, "state"); + s4o.print(" = 1;\n" + s4o.indent_spaces); + print_step_argument(step_name, "elapsed_time"); + s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); + } + + bool is_variable(symbol_c *symbol) { + /* we try to find the variable instance declaration, to determine its type... */ + symbol_c *var_decl = search_var_instance_decl->get_decl(symbol); + + return var_decl != NULL; + } + +/*********************************************/ +/* B.1.6 Sequential function chart elements */ +/*********************************************/ + + void *visit(initial_step_c *symbol) { + switch (wanted_sfcgeneration) { + case actionassociation_sg: + if (((list_c*)symbol->action_association_list)->n > 0) { + s4o.print(s4o.indent_spaces + "// "); + symbol->step_name->accept(*this); + s4o.print(" action associations\n"); + current_step = symbol->step_name; + s4o.print(s4o.indent_spaces + "{\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces + "char activated = "); + print_step_argument(current_step, "state"); + s4o.print(" && !"); + print_step_argument(current_step, "prev_state"); + s4o.print(";\n"); + s4o.print(s4o.indent_spaces + "char desactivated = !"); + print_step_argument(current_step, "state"); + s4o.print(" && "); + print_step_argument(current_step, "prev_state"); + s4o.print(";\n"); + s4o.print(s4o.indent_spaces + "char active = "); + print_step_argument(current_step, "state"); + s4o.print(";\n"); + symbol->action_association_list->accept(*this); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n\n"); + } + break; + default: + break; + } + return NULL; + } + + void *visit(step_c *symbol) { + switch (wanted_sfcgeneration) { + case actionassociation_sg: + if (((list_c*)symbol->action_association_list)->n > 0) { + s4o.print(s4o.indent_spaces + "// "); + symbol->step_name->accept(*this); + s4o.print(" action associations\n"); + current_step = symbol->step_name; + s4o.print(s4o.indent_spaces + "{\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces + "char activated = "); + print_step_argument(current_step, "state"); + s4o.print(" && !"); + print_step_argument(current_step, "prev_state"); + s4o.print(";\n"); + s4o.print(s4o.indent_spaces + "char desactivated = !"); + print_step_argument(current_step, "state"); + s4o.print(" && "); + print_step_argument(current_step, "prev_state"); + s4o.print(";\n"); + s4o.print(s4o.indent_spaces + "char active = "); + print_step_argument(current_step, "state"); + s4o.print(";\n"); + symbol->action_association_list->accept(*this); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n\n"); + } + break; + default: + break; + } + return NULL; + } + + void *visit(transition_c *symbol) { + switch (wanted_sfcgeneration) { + case transitionlist_sg: + { + TRANSITION *transition; + transition = new TRANSITION; + transition->symbol = symbol; + transition->index = transition_number; + if (symbol->integer != NULL) { + transition->priority = atoi(((token_c *)symbol->integer)->value); + std::list::iterator pt = transition_list.begin(); + while (pt != transition_list.end() && pt->priority <= transition->priority) { + pt++; + } + transition_list.insert(pt, *transition); + } + else { + transition->priority = 0; + transition_list.push_back(*transition); + } + transition_number++; + } + break; + case transitiontest_sg: + s4o.print(s4o.indent_spaces + "if ("); + symbol->from_steps->accept(*this); + s4o.print(") {\n"); + s4o.indent_right(); + + // Calculate transition value + if (symbol->transition_condition_il != NULL) { + generate_c_il->declare_backup_variable(); + s4o.print(s4o.indent_spaces); + symbol->transition_condition_il->accept(*generate_c_il); + print_variable_prefix(); + s4o.print("transition_list["); + print_transition_number(); + s4o.print("] = "); + generate_c_il->print_backup_variable(); + s4o.print(";\n"); + } + if (symbol->transition_condition_st != NULL) { + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("transition_list["); + print_transition_number(); + s4o.print("] = "); + symbol->transition_condition_st->accept(*generate_c_st); + s4o.print(";\n"); + } + if (symbol->integer != NULL) { + s4o.print(s4o.indent_spaces + "if ("); + print_variable_prefix(); + s4o.print("transition_list["); + print_transition_number(); + s4o.print("]) {\n"); + s4o.indent_right(); + wanted_sfcgeneration = stepreset_sg; + symbol->from_steps->accept(*this); + wanted_sfcgeneration = transitiontest_sg; + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + } + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces + "else {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("transition_list["); + print_transition_number(); + s4o.print("] = 0;\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + break; + case stepset_sg: + s4o.print(s4o.indent_spaces + "if ("); + print_variable_prefix(); + s4o.print("transition_list["); + print_transition_number(); + s4o.print("]) {\n"); + s4o.indent_right(); + symbol->to_steps->accept(*this); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + transition_number++; + break; + case stepreset_sg: + if (symbol->integer == NULL) { + s4o.print(s4o.indent_spaces + "if ("); + print_variable_prefix(); + s4o.print("transition_list["); + print_transition_number(); + s4o.print("]) {\n"); + s4o.indent_right(); + symbol->from_steps->accept(*this); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + } + transition_number++; + break; + default: + break; + } + return NULL; + } + + void *visit(action_c *symbol) { + switch (wanted_sfcgeneration) { + case actionbody_sg: + s4o.print(s4o.indent_spaces + "if("); + print_variable_prefix(); + s4o.print("action_list["); + s4o.print(SFC_STEP_ACTION_PREFIX); + symbol->action_name->accept(*this); + s4o.print("].state) {"); + s4o.indent_right(); + + // generate action code + symbol->function_block_body->accept(*generate_c_code); + + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n\n"); + break; + default: + break; + } + return NULL; + } + + void *visit(steps_c *symbol) { + if (symbol->step_name != NULL) { + switch (wanted_sfcgeneration) { + case transitiontest_sg: + print_step_argument(symbol->step_name, "state"); + break; + case stepset_sg: + print_set_step(symbol->step_name); + break; + case stepreset_sg: + print_reset_step(symbol->step_name); + break; + default: + break; + } + } + else if (symbol->step_name_list != NULL) { + symbol->step_name_list->accept(*this); + } + return NULL; + } + + void *visit(step_name_list_c *symbol) { + switch (wanted_sfcgeneration) { + case transitiontest_sg: + for(int i = 0; i < symbol->n; i++) { + print_step_argument(symbol->elements[i], "state"); + if (i < symbol->n - 1) { + s4o.print(" && "); + } + } + break; + case stepset_sg: + for(int i = 0; i < symbol->n; i++) { + print_set_step(symbol->elements[i]); + } + break; + case stepreset_sg: + for(int i = 0; i < symbol->n; i++) { + print_reset_step(symbol->elements[i]); + } + break; + default: + break; + } + return NULL; + } + + void *visit(action_association_list_c* symbol) { + switch (wanted_sfcgeneration) { + case actionassociation_sg: + print_list(symbol, "", "\n", "\n"); + break; + default: + break; + } + return NULL; + } + + void *visit(action_association_c *symbol) { + switch (wanted_sfcgeneration) { + case actionassociation_sg: + if (symbol->action_qualifier != NULL) { + current_action = symbol->action_name; + symbol->action_qualifier->accept(*this); + } + else { + s4o.print(s4o.indent_spaces + "if ("); + print_step_argument(current_step, "state"); + s4o.print(") {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_action_argument(symbol->action_name, "state"); + s4o.print(" = 1;\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}"); + } + break; + default: + break; + } + return NULL; + } + + void *visit(action_qualifier_c *symbol) { + switch (wanted_sfcgeneration) { + case actionassociation_sg: + { + char *qualifier = (char *)symbol->action_qualifier->accept(*this); + s4o.print(s4o.indent_spaces + "if ("); + if (strcmp(qualifier, "N") == 0) { + s4o.print("active"); + } + if (strcmp(qualifier, "P") == 0 || strcmp(qualifier, "SD") == 0 || + strcmp(qualifier, "DS") == 0 || strcmp(qualifier, "SL") == 0 || + strcmp(qualifier, "S") == 0 || strcmp(qualifier, "R") == 0) { + s4o.print("activated"); + } + if (strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) { + s4o.print("active && "); + print_step_argument(current_step, "elapsed_time"); + if (strcmp(qualifier, "D") == 0) { + s4o.print(" >= "); + } + else { + s4o.print(" < "); + } + symbol->action_time->accept(*this); + } + s4o.print(") {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + if (strcmp(qualifier, "N") == 0 || strcmp(qualifier, "P") == 0 || + strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) { + print_action_argument(current_action, "state"); + s4o.print(" = 1;\n"); + } + if (strcmp(qualifier, "S") == 0) { + if (is_variable(current_action)) { + print_variable_prefix(); + current_action->accept(*this); + } + else + print_action_argument(current_action, "set"); + s4o.print(" = 1;\n"); + } + if (strcmp(qualifier, "R") == 0) { + if (is_variable(current_action)) { + print_variable_prefix(); + current_action->accept(*this); + s4o.print(" = 0;\n"); + } + else { + print_action_argument(current_action, "reset"); + s4o.print(" = 1;\n"); + } + } + if (strcmp(qualifier, "SD") == 0 || strcmp(qualifier, "DS") == 0 || + strcmp(qualifier, "SL") == 0) { + if (strcmp(qualifier, "SL") == 0) { + print_action_argument(current_action, "reset_remaining_time"); + } + else { + print_action_argument(current_action, "set_remaining_time"); + } + s4o.print(" = "); + symbol->action_time->accept(*this); + s4o.print(";\n"); + } + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}"); + if (strcmp(qualifier, "DS") == 0) { + s4o.print("desactivated"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_action_argument(current_action, "set_remaining_time"); + s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); + } + } + break; + default: + break; + } + return NULL; + } + + void *visit(qualifier_c *symbol) { + return (void *)symbol->value; + } + + void *visit(timed_qualifier_c *symbol) { + return (void *)symbol->value; + } + +}; /* generate_c_sfc_actiondecl_c */ + + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + +class generate_c_sfc_c: public generate_c_typedecl_c { + + private: + generate_c_sfc_elements_c *generate_c_sfc_elements; + + public: + generate_c_sfc_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) + : generate_c_typedecl_c(s4o_ptr) { + generate_c_sfc_elements = new generate_c_sfc_elements_c(s4o_ptr, scope, variable_prefix); + this->set_variable_prefix(variable_prefix); + } + + virtual ~generate_c_sfc_c(void) { + delete generate_c_sfc_elements; + } + +/*********************************************/ +/* B.1.6 Sequential function chart elements */ +/*********************************************/ + + void *visit(sfc_network_c *symbol) { + generate_c_sfc_elements->generate((symbol_c *) symbol, generate_c_sfc_elements_c::transitionlist_sg); + s4o.print(s4o.indent_spaces +"INT i;\n\n"); + s4o.print(s4o.indent_spaces +"BOOL transition;\n\n"); + + /* generate step initilizations */ + s4o.print(s4o.indent_spaces + "// Steps initialisation\n"); + s4o.print(s4o.indent_spaces + "for (i = 0; i < "); + print_variable_prefix(); + s4o.print("nb_steps; i++) {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("step_list[i].prev_state = "); + print_variable_prefix(); + s4o.print("step_list[i].state;\n"); + s4o.print(s4o.indent_spaces + "if ("); + print_variable_prefix(); + s4o.print("step_list[i].state) {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("step_list[i].elapsed_time = __time_add("); + print_variable_prefix(); + s4o.print("step_list[i].elapsed_time, "); + print_variable_prefix(); + s4o.print("period);\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + + /* generate action initilizations */ + s4o.print(s4o.indent_spaces + "// Actions initialisation\n"); + s4o.print(s4o.indent_spaces + "for (i = 0; i < "); + print_variable_prefix(); + s4o.print("nb_actions; i++) {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].state = 0;\n"); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].set = 0;\n"); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].reset = 0;\n"); + s4o.print(s4o.indent_spaces + "if ("); + s4o.print("__gt_TIME(2, "); + print_variable_prefix(); + s4o.print("action_list[i].set_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0))) {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].set_remaining_time = __time_sub("); + print_variable_prefix(); + s4o.print("action_list[i].set_remaining_time, "); + print_variable_prefix(); + s4o.print("period);\n"); + s4o.print(s4o.indent_spaces + "if ("); + s4o.print("__le_TIME(2, "); + print_variable_prefix(); + s4o.print("action_list[i].set_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0))) {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].set_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].set = 1;\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + s4o.print(s4o.indent_spaces + "if ("); + s4o.print("__gt_TIME(2, "); + print_variable_prefix(); + s4o.print("action_list[i].reset_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0))) {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].reset_remaining_time = __time_sub("); + print_variable_prefix(); + s4o.print("action_list[i].reset_remaining_time, "); + print_variable_prefix(); + s4o.print("period);\n"); + s4o.print(s4o.indent_spaces + "if ("); + s4o.print("__le_TIME(2, "); + print_variable_prefix(); + s4o.print("action_list[i].reset_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0))) {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].reset_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].reset = 1;\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n\n"); + + /* generate transition tests */ + s4o.print(s4o.indent_spaces + "// Transitions fire test\n"); + generate_c_sfc_elements->generate((symbol_c *) symbol, generate_c_sfc_elements_c::transitiontest_sg); + s4o.print("\n"); + + /* generate transition reset steps */ + s4o.print(s4o.indent_spaces + "// Transitions reset steps\n"); + generate_c_sfc_elements->reset_transition_number(); + generate_c_sfc_elements->generate((symbol_c *) symbol, generate_c_sfc_elements_c::stepreset_sg); + s4o.print("\n"); + + /* generate transition set steps */ + s4o.print(s4o.indent_spaces + "// Transitions set steps\n"); + generate_c_sfc_elements->reset_transition_number(); + generate_c_sfc_elements->generate((symbol_c *) symbol, generate_c_sfc_elements_c::stepset_sg); + s4o.print("\n"); + + /* generate step association */ + s4o.print(s4o.indent_spaces + "// Steps association\n"); + generate_c_sfc_elements->generate((symbol_c *) symbol, generate_c_sfc_elements_c::actionassociation_sg); + s4o.print("\n"); + + /* generate action state evaluation */ + s4o.print(s4o.indent_spaces + "// Actions state evaluation\n"); + s4o.print(s4o.indent_spaces + "for (i = 0; i < "); + print_variable_prefix(); + s4o.print("nb_actions; i++) {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces + "if ("); + print_variable_prefix(); + s4o.print("action_list[i].set) {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].stored = 1;\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces + "if ("); + print_variable_prefix(); + s4o.print("action_list[i].reset) {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].set_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n" + s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].reset_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n" + s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].stored = 0;\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i].state |= "); + print_variable_prefix(); + s4o.print("action_list[i].stored;\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n\n"); + + /* generate action execution */ + s4o.print(s4o.indent_spaces + "// Actions execution\n"); + generate_c_sfc_elements->generate((symbol_c *) symbol, generate_c_sfc_elements_c::actionbody_sg); + s4o.print("\n"); + + return NULL; + } + + void generate(sequential_function_chart_c *sfc) { + sfc->accept(*this); + } + +}; /* generate_c_sfc_c */ diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/generate_c_sfcdecl.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/generate_c_sfcdecl.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,308 @@ +/* + * (c) 2007 Mario de Sousa, Laurent Bessard + * + * 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) + * + */ + + +/* + * Conversion of sfc networks (i.e. SFC code). + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the SFC, IL and ST + * code. + */ + + + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + +class generate_c_sfcdecl_c: protected generate_c_typedecl_c { + + public: + typedef enum { + sfcdecl_sd, + sfcinit_sd, + stepcount_sd, + stepdef_sd, + stepundef_sd, + actiondef_sd, + actionundef_sd, + actioncount_sd + } sfcdeclaration_t; + + private: + char step_number; + char action_number; + char transition_number; + + sfcdeclaration_t wanted_sfcdeclaration; + + public: + generate_c_sfcdecl_c(stage4out_c *s4o_ptr, sfcdeclaration_t sfcdeclaration) + : generate_c_typedecl_c(s4o_ptr) { + wanted_sfcdeclaration = sfcdeclaration; + } + ~generate_c_sfcdecl_c(void) {} + + void print(symbol_c *symbol, const char *variable_prefix = NULL) { + this->set_variable_prefix(variable_prefix); + + symbol->accept(*this); + } + +/*********************************************/ +/* B.1.6 Sequential function chart elements */ +/*********************************************/ + + void *visit(sequential_function_chart_c *symbol) { + step_number = 0; + action_number = 0; + transition_number = 0; + switch (wanted_sfcdeclaration) { + case sfcdecl_sd: + for(int i = 0; i < symbol->n; i++) + symbol->elements[i]->accept(*this); + + /* steps table declaration */ + s4o.print(s4o.indent_spaces + "STEP step_list["); + s4o.print_integer(step_number); + s4o.print("];\n"); + s4o.print(s4o.indent_spaces + "UINT nb_steps;\n"); + + /* actions table declaration */ + s4o.print(s4o.indent_spaces + "ACTION action_list["); + s4o.print_integer(action_number); + s4o.print("];\n"); + s4o.print(s4o.indent_spaces + "UINT nb_actions;\n"); + + /* transitions table declaration */ + s4o.print(s4o.indent_spaces + "USINT transition_list["); + s4o.print_integer(transition_number); + s4o.print("];\n"); + + /* period declaration */ + s4o.print(s4o.indent_spaces + "TIME period;\n"); + break; + case sfcinit_sd: + s4o.print(s4o.indent_spaces); + s4o.print("UINT i;\n"); + + /* steps table count */ + wanted_sfcdeclaration = stepcount_sd; + for(int i = 0; i < symbol->n; i++) + symbol->elements[i]->accept(*this); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("nb_steps = "); + s4o.print_integer(step_number); + s4o.print(";\n"); + step_number = 0; + wanted_sfcdeclaration = sfcinit_sd; + + /* steps table initialisation */ + s4o.print(s4o.indent_spaces + "STEP temp_step = {0, 0, 0};\n"); + s4o.print(s4o.indent_spaces + "for(i = 0; i < "); + print_variable_prefix(); + s4o.print("nb_steps; i++) {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("step_list[i] = temp_step;\n"); + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + for(int i = 0; i < symbol->n; i++) + symbol->elements[i]->accept(*this); + + /* steps table count */ + wanted_sfcdeclaration = actioncount_sd; + for(int i = 0; i < symbol->n; i++) + symbol->elements[i]->accept(*this); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("nb_actions = "); + s4o.print_integer(action_number); + s4o.print(";\n"); + action_number = 0; + wanted_sfcdeclaration = sfcinit_sd; + + /* actions table initialisation */ + s4o.print(s4o.indent_spaces + "ACTION temp_action = {0, 0, 0, 0, 0, 0};\n"); + s4o.print(s4o.indent_spaces + "for(i = 0; i < "); + print_variable_prefix(); + s4o.print("nb_actions; i++) {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("action_list[i] = temp_action;\n"); + + /* period initialisation */ + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("period = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); + + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}\n"); + break; + case stepdef_sd: + s4o.print("// Steps definitions\n"); + for(int i = 0; i < symbol->n; i++) + symbol->elements[i]->accept(*this); + s4o.print("\n"); + break; + case actiondef_sd: + s4o.print("// Actions definitions\n"); + for(int i = 0; i < symbol->n; i++) + symbol->elements[i]->accept(*this); + s4o.print("\n"); + break; + case stepundef_sd: + s4o.print("// Steps undefinitions\n"); + for(int i = 0; i < symbol->n; i++) + symbol->elements[i]->accept(*this); + s4o.print("\n"); + break; + case actionundef_sd: + s4o.print("// Actions undefinitions\n"); + for(int i = 0; i < symbol->n; i++) + symbol->elements[i]->accept(*this); + s4o.print("\n"); + break; + default: + break; + } + return NULL; + } + + void *visit(initial_step_c *symbol) { + switch (wanted_sfcdeclaration) { + case stepcount_sd: + case sfcdecl_sd: + step_number++; + break; + case sfcinit_sd: + s4o.print(s4o.indent_spaces); + print_variable_prefix(); + s4o.print("step_list["); + s4o.print_integer(step_number); + s4o.print("].state = 1;\n"); + step_number++; + break; + case stepdef_sd: + s4o.print("#define "); + s4o.print(SFC_STEP_ACTION_PREFIX); + symbol->step_name->accept(*this); + s4o.print(" "); + s4o.print_integer(step_number); + s4o.print("\n"); + step_number++; + break; + case stepundef_sd: + s4o.print("#undef "); + s4o.print(SFC_STEP_ACTION_PREFIX); + symbol->step_name->accept(*this); + s4o.print("\n"); + break; + default: + break; + } + return NULL; + } + + void *visit(step_c *symbol) { + switch (wanted_sfcdeclaration) { + case stepcount_sd: + case sfcdecl_sd: + step_number++; + break; + case stepdef_sd: + s4o.print("#define "); + s4o.print(SFC_STEP_ACTION_PREFIX); + symbol->step_name->accept(*this); + s4o.print(" "); + s4o.print_integer(step_number); + s4o.print("\n"); + step_number++; + break; + case stepundef_sd: + s4o.print("#undef "); + s4o.print(SFC_STEP_ACTION_PREFIX); + symbol->step_name->accept(*this); + s4o.print("\n"); + break; + default: + break; + } + return NULL; + } + + void *visit(transition_c *symbol) { + switch (wanted_sfcdeclaration) { + case sfcdecl_sd: + transition_number++; + break; + default: + break; + } + return NULL; + } + + void *visit(action_c *symbol) { + switch (wanted_sfcdeclaration) { + case actiondef_sd: + s4o.print("#define "); + s4o.print(SFC_STEP_ACTION_PREFIX); + symbol->action_name->accept(*this); + s4o.print(" "); + s4o.print_integer(action_number); + s4o.print("\n"); + action_number++; + break; + case actionundef_sd: + s4o.print("#undef "); + s4o.print(SFC_STEP_ACTION_PREFIX); + symbol->action_name->accept(*this); + s4o.print("\n"); + break; + case actioncount_sd: + case sfcdecl_sd: + action_number++; + break; + default: + break; + } + return NULL; + } + + void *visit(instruction_list_c *symbol) { + return NULL; + } + + void *visit(statement_list_c *symbol) { + return NULL; + } + +}; /* generate_c_sfcdecl_c */ + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/generate_c_st.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/generate_c_st.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,847 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * Conversion of st statements (i.e. ST code). + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the IL and ST + * code. + */ + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + + +class generate_c_st_c: public generate_c_typedecl_c { + + private: + /* When calling a function block, we must first find it's type, + * by searching through the declarations of the variables currently + * in scope. + * This class does just that... + * A new class is instantiated whenever we begin generating the code + * for a function block type declaration, or a program declaration. + * This object instance will then later be called while the + * function block's or the program's body is being handled. + * + * Note that functions cannot contain calls to function blocks, + * so we do not create an object instance when handling + * a function declaration. + */ + search_fb_instance_decl_c *search_fb_instance_decl; + + /* When compiling st code, it becomes necessary to determine the + * data type of st expressions. To do this, we must first find the + * st operand's declaration, within the scope of the function block + * or function currently being processed. + * The following object does just that... + * This object instance will then later be called while the + * remaining st code is being handled. + */ + search_expression_type_c *search_expression_type; + + search_varfb_instance_type_c *search_varfb_instance_type; + + public: + generate_c_st_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) + : generate_c_typedecl_c(s4o_ptr) { + search_fb_instance_decl = new search_fb_instance_decl_c(scope); + search_expression_type = new search_expression_type_c(scope); + search_varfb_instance_type = new search_varfb_instance_type_c(scope); + this->set_variable_prefix(variable_prefix); + } + + virtual ~generate_c_st_c(void) { + delete search_fb_instance_decl; + delete search_expression_type; + delete search_varfb_instance_type; + } + + + private: + /* Some function calls in the body of functions or function blocks + * may leave some parameters to their default values, and + * ignore some output parameters of the function being called. + * Our conversion of ST functions to C++ does not contemplate that, + * i.e. each called function must get all it's input and output + * parameters set correctly. + * For input parameters we merely need to call the function with + * the apropriate default value, but for output parameters + * we must create temporary variables to hold the output value. + * + * We declare all the temporary output variables at the begining of + * the body of each function or function block, and use them as + * in function calls later on as they become necessary... + * Note that we cannot create these variables just before a function + * call, as the function call itself may be integrated within an + * expression, or another function call! + * + * The variables are declared in the exact same order in which they + * will be used later on during the function calls, which allows us + * to simply re-create the name that was used for the temporary variable + * instead of keeping it in some list. + * The names are recreated by the temp_var_name_factory, after reset() + * has been called! + * + * This function will genertae code similar to... + * + * INT __TMP_0 = 23; + * REAL __TMP_1 = 45.5; + * ... + */ + temp_var_name_c temp_var_name_factory; + + public: + void generate(statement_list_c *stl) { + generate_c_tempvardecl_c generate_c_tempvardecl(&s4o); + generate_c_tempvardecl.generate(stl, &temp_var_name_factory); + stl->accept(*this); + } + + private: + +/*********************/ +/* B 1.4 - Variables */ +/*********************/ +void *visit(symbolic_variable_c *symbol) { + unsigned int vartype = search_varfb_instance_type->get_vartype(symbol); + if (vartype == search_var_instance_decl_c::external_vt || vartype == search_var_instance_decl_c::located_vt) { + s4o.print("*("); + generate_c_base_c::visit(symbol); + s4o.print(")"); + } + else { + generate_c_base_c::visit(symbol); + } + return NULL; +} + +/********************************************/ +/* B.1.4.1 Directly Represented Variables */ +/********************************************/ +// direct_variable: direct_variable_token {$$ = new direct_variable_c($1);}; +void *visit(direct_variable_c *symbol) { + TRACE("direct_variable_c"); + /* Do not use print_token() as it will change everything into uppercase */ + if (strlen(symbol->value) == 0) ERROR; + s4o.print("*("); + this->print_variable_prefix(); + s4o.printlocation(symbol->value + 1); + s4o.print(")"); + return NULL; +} + +/***************************************/ +/* B.3 - Language ST (Structured Text) */ +/***************************************/ +/***********************/ +/* B 3.1 - Expressions */ +/***********************/ +void *visit(or_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_bool_type(left_type)) + return print_binary_expression(symbol->l_exp, symbol->r_exp, " || "); + if (search_expression_type->is_binary_type(left_type)) + return print_binary_expression(symbol->l_exp, symbol->r_exp, " | "); + ERROR; + return NULL; +} + +void *visit(xor_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_bool_type(left_type)) { + s4o.print("("); + symbol->l_exp->accept(*this); + s4o.print(" && !"); + symbol->r_exp->accept(*this); + s4o.print(") || (!"); + symbol->l_exp->accept(*this); + s4o.print(" && "); + symbol->r_exp->accept(*this); + s4o.print(")"); + } + if (search_expression_type->is_binary_type(left_type)) + return print_binary_expression(symbol->l_exp, symbol->r_exp, " ^ "); + ERROR; + return NULL; +} + +void *visit(and_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_bool_type(left_type)) + return print_binary_expression(symbol->l_exp, symbol->r_exp, " && "); + if (search_expression_type->is_binary_type(left_type)) + return print_binary_expression(symbol->l_exp, symbol->r_exp, " & "); + ERROR; + return NULL; +} + +void *visit(equ_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_time_type(left_type)) + return print_compare_function("__eq_", left_type, symbol->l_exp, symbol->r_exp); + return print_binary_expression(symbol->l_exp, symbol->r_exp, " == "); +} + +void *visit(notequ_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_time_type(left_type)) + return print_compare_function("__ne_", left_type, symbol->l_exp, symbol->r_exp); + return print_binary_expression(symbol->l_exp, symbol->r_exp, " != "); +} + +void *visit(lt_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_time_type(left_type)) + return print_compare_function("__lt_", left_type, symbol->l_exp, symbol->r_exp); + return print_binary_expression(symbol->l_exp, symbol->r_exp, " < "); +} + +void *visit(gt_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_time_type(left_type)) + return print_compare_function("__gt_", left_type, symbol->l_exp, symbol->r_exp); + return print_binary_expression(symbol->l_exp, symbol->r_exp, " > "); +} + +void *visit(le_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_time_type(left_type)) + return print_compare_function("__le_", left_type, symbol->l_exp, symbol->r_exp); + return print_binary_expression(symbol->l_exp, symbol->r_exp, " <= "); +} + +void *visit(ge_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_time_type(left_type)) + return print_compare_function("__ge_", left_type, symbol->l_exp, symbol->r_exp); + return print_binary_expression(symbol->l_exp, symbol->r_exp, " >= "); +} + +void *visit(add_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) || + (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) || + (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c))) + return print_binary_function("__time_add", symbol->l_exp, symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type)) + return print_binary_expression(symbol->l_exp, symbol->r_exp, " + "); + ERROR; + return NULL; +} + +void *visit(sub_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) || + (typeid(*left_type) == typeid(date_type_name_c) && typeid(*right_type) == typeid(date_type_name_c)) || + (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) || + (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(tod_type_name_c)) || + (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) || + (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(dt_type_name_c))) + return print_binary_function("__time_sub", symbol->l_exp, symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type)) + return print_binary_expression(symbol->l_exp, symbol->r_exp, " - "); + ERROR; + return NULL; +} + +void *visit(mul_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if ((typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_integer_type(right_type)) || + (typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_real_type(right_type))) + return print_binary_function("__time_mul", symbol->l_exp, symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type)) + return print_binary_expression(symbol->l_exp, symbol->r_exp, " * "); + ERROR; + return NULL; +} + +void *visit(div_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type)) + return print_binary_expression(symbol->l_exp, symbol->r_exp, " / "); + ERROR; + return NULL; +} + +void *visit(mod_expression_c *symbol) { + symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); + symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); + if (!search_expression_type->is_same_type(left_type, right_type)) + ERROR; + if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type)) { + s4o.print("(("); + symbol->r_exp->accept(*this); + s4o.print(" == 0)?0:"); + print_binary_expression(symbol->l_exp, symbol->r_exp, " % "); + s4o.print(")"); + return NULL; + } + ERROR; + return NULL; +} + +/* TODO: power expression... */ +void *visit(power_expression_c *symbol) {ERROR; return print_binary_expression(symbol->l_exp, symbol->r_exp, " ** ");} +void *visit(neg_expression_c *symbol) {return print_unary_expression(symbol->exp, " -");} + +void *visit(not_expression_c *symbol) { + symbol_c *exp_type = search_expression_type->get_type(symbol->exp); + if (!search_expression_type->is_binary_type(exp_type)) + ERROR; + return print_unary_expression(symbol->exp, search_expression_type->is_bool_type(exp_type)?"!":"~"); +} + +void *visit(function_invocation_c *symbol) { + function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name); + + if (f_decl == function_symtable.end_value()) { + /* The function called is not in the symtable, so we test if it is a + * standard function defined in standard */ + + function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name); + if (current_function_type == function_none) ERROR; + + symbol_c *function_return_type = search_expression_type->get_type(symbol); + + function_call_param_iterator_c function_call_param_iterator(symbol); + + int nb_param = ((list_c *)symbol->parameter_assignment_list)->n; + +#include "st_code_gen.c" + +#if 0 + for(int current_param = 0; current_param < nb_param; current_param++) { + symbol_c *param_name = NULL; + switch (current_function_type) { + case function_add: + case function_and: + case function_or: + param_name = generate_param_name("IN%d", current_param + 1); + break; + case function_sub: + if (current_param < 2) + param_name = generate_param_name("IN%d", current_param + 1); + else + ERROR; + break; + default: ERROR; + } + + /* Get the value from a foo( = ) style call */ + symbol_c *param_value = function_call_param_iterator.search(param_name); + delete param_name; + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + + if (param_value == NULL) ERROR; + + switch (current_function_type) { + case function_add: + if (search_expression_type->is_time_type(function_return_type)) { + if (current_param == 0) { + s4o.print("__time_add("); + param_value->accept(*this); + } + else if (current_param == 1) { + s4o.print(", "); + param_value->accept(*this); + s4o.print(")"); + } + else ERROR; + } + else { + if (current_param == 0) + s4o.print("("); + else + s4o.print(" + "); + param_value->accept(*this); + if (current_param == nb_param - 1) + s4o.print(")"); + } + break; + case function_sub: + if (search_expression_type->is_time_type(function_return_type)) { + if (current_param == 0) { + s4o.print("__time_sub("); + param_value->accept(*this); + } + else if (current_param == 1) { + s4o.print(", "); + param_value->accept(*this); + s4o.print(")"); + } + else ERROR; + } + else { + if (current_param == 0) { + s4o.print("("); + param_value->accept(*this); + } + else if (current_param == 1) { + s4o.print(" - "); + param_value->accept(*this); + s4o.print(")"); + } + else ERROR; + } + break; + case function_and: + if (current_param == 0) + s4o.print("("); + else + if (search_expression_type->is_bool_type(function_return_type)) + s4o.print(" && "); + else + s4o.print(" & "); + param_value->accept(*this); + if (current_param == nb_param - 1) + s4o.print(")"); + break; + case function_or: + if (current_param == 0) + s4o.print("("); + else + if (search_expression_type->is_bool_type(function_return_type)) + s4o.print(" || "); + else + s4o.print(" | "); + param_value->accept(*this); + if (current_param == nb_param - 1) + s4o.print(")"); + break; + default: ERROR; + } + } /* for(...) */ +#endif + } + else { + /* loop through each function parameter, find the value we should pass + * to it, and then output the c equivalent... + */ + function_param_iterator_c fp_iterator(f_decl); + + symbol->function_name->accept(*this); + s4o.print("("); + s4o.indent_right(); + + identifier_c *param_name; + function_call_param_iterator_c function_call_param_iterator(symbol); + for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { + if (i != 1) + s4o.print(",\n"+s4o.indent_spaces); + + function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); + + /* Get the value from a foo( = ) style call */ + symbol_c *param_value = function_call_param_iterator.search(param_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + + symbol_c *param_type = fp_iterator.param_type(); + if (param_type == NULL) ERROR; + + switch (param_direction) { + case function_param_iterator_c::direction_in: + if (param_value == NULL) { + /* No value given for parameter, so we must use the default... */ + /* First check whether default value specified in function declaration...*/ + param_value = fp_iterator.default_value(); + } + if (param_value == NULL) { + /* If not, get the default value of this variable's type */ + param_value = (symbol_c *)param_type->accept(*type_initial_value_c::instance()); + } + if (param_value == NULL) ERROR; + param_value->accept(*this); + break; + case function_param_iterator_c::direction_out: + case function_param_iterator_c::direction_inout: + if (param_value == NULL) { + /* no parameter value given, so we pass a previously declared temporary variable. */ + std::string *temp_var_name = temp_var_name_factory.new_name(); + s4o.print(*temp_var_name); + delete temp_var_name; + } else { + param_value->accept(*this); + } + break; + case function_param_iterator_c::direction_extref: + /* TODO! */ + ERROR; + break; + } /* switch */ + } /* for(...) */ + // symbol->parameter_assignment->accept(*this); + s4o.print(")"); + s4o.indent_left(); + } + + return NULL; +} + +/********************/ +/* B 3.2 Statements */ +/********************/ +void *visit(statement_list_c *symbol) { + return print_list(symbol, s4o.indent_spaces, ";\n" + s4o.indent_spaces, ";\n"); +} + +/*********************************/ +/* B 3.2.1 Assignment Statements */ +/*********************************/ +void *visit(assignment_statement_c *symbol) { + symbol->l_exp->accept(*this); + s4o.print(" = "); + symbol->r_exp->accept(*this); + return NULL; +} + +/*****************************************/ +/* B 3.2.2 Subprogram Control Statements */ +/*****************************************/ + +/* fb_name '(' [param_assignment_list] ')' */ +/* param_assignment_list -> may be NULL ! */ +//SYM_REF2(fb_invocation_c, fb_name, param_assignment_list) +void *visit(fb_invocation_c *symbol) { + TRACE("fb_invocation_c"); + /* first figure out what is the name of the function block type of the function block being called... */ + symbol_c *function_block_type_name = this->search_fb_instance_decl->get_type_name(symbol->fb_name); + /* should never occur. The function block instance MUST have been declared... */ + if (function_block_type_name == NULL) ERROR; + + /* Now find the declaration of the function block type being called... */ + function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(function_block_type_name); + /* should never occur. The function block type being called MUST be in the symtable... */ + if (fb_decl == function_block_type_symtable.end_value()) ERROR; + + /* loop through each function block parameter, find the value we should pass + * to it, and then output the c equivalent... + */ + function_param_iterator_c fp_iterator(fb_decl); + identifier_c *param_name; + function_call_param_iterator_c function_call_param_iterator(symbol); + for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { + function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); + + /* Get the value from a foo( = ) style call */ + symbol_c *param_value = function_call_param_iterator.search(param_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + + /* now output the value assignment */ + if (param_value != NULL) + if ((param_direction == function_param_iterator_c::direction_in) || + (param_direction == function_param_iterator_c::direction_inout)) { + print_variable_prefix(); + symbol->fb_name->accept(*this); + s4o.print("."); + param_name->accept(*this); + s4o.print(" = "); + param_value->accept(*this); + s4o.print(";\n" + s4o.indent_spaces); + } + } /* for(...) */ + + /* now call the function... */ + function_block_type_name->accept(*this); + s4o.print(FB_FUNCTION_SUFFIX); + s4o.print("(&"); + print_variable_prefix(); + symbol->fb_name->accept(*this); + s4o.print(")"); + + /* loop through each function parameter, find the variable to which + * we should atribute the value of all output or inoutput parameters. + */ + fp_iterator.reset(); + function_call_param_iterator.reset(); + for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { + function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); + + /* Get the value from a foo( = ) style call */ + symbol_c *param_value = function_call_param_iterator.search(param_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + + /* now output the value assignment */ + if (param_value != NULL) + if ((param_direction == function_param_iterator_c::direction_out) || + (param_direction == function_param_iterator_c::direction_inout)) { + s4o.print(";\n"+ s4o.indent_spaces); + param_value->accept(*this); + s4o.print(" = "); + print_variable_prefix(); + symbol->fb_name->accept(*this); + s4o.print("."); + param_name->accept(*this); + } + } /* for(...) */ + + return NULL; +} + + + + +/* helper symbol for fb_invocation */ +/* param_assignment_list ',' param_assignment */ +void *visit(param_assignment_list_c *symbol) { + TRACE("param_assignment_list_c"); + /* this should never be called... */ + ERROR; + return NULL; +// return print_list(symbol, "", ", "); +} + + +void *visit(input_variable_param_assignment_c *symbol) { + TRACE("input_variable_param_assignment_c"); + /* this should never be called... */ + ERROR; + return NULL; +/* + symbol->variable_name->accept(*this); + s4o.print(" = "); + symbol->expression->accept(*this); + return NULL; +*/ +} + +void *visit(output_variable_param_assignment_c *symbol) { + TRACE("output_variable_param_assignment_c"); + /* this should never be called... */ + ERROR; + return NULL; +/* + s4o.print(s4o.indent_spaces); + if (symbol->not_param != NULL) + symbol->not_param->accept(*this); + symbol->variable_name->accept(*this); + s4o.print(" => "); + symbol->variable->accept(*this); + return NULL; +*/ +} + +// TODO: the NOT symbol in function (block) calls... +void *visit(not_paramassign_c *symbol) { + TRACE("not_paramassign_c"); + /* this should never be called... */ + ERROR; + return NULL; +/* + s4o.print("NOT "); + return NULL; +*/ +} + + +/********************************/ +/* B 3.2.3 Selection Statements */ +/********************************/ +void *visit(if_statement_c *symbol) { + s4o.print("if ("); + symbol->expression->accept(*this); + s4o.print(") {\n"); + s4o.indent_right(); + symbol->statement_list->accept(*this); + s4o.indent_left(); + symbol->elseif_statement_list->accept(*this); + + if (symbol->else_statement_list != NULL) { + s4o.print(s4o.indent_spaces); s4o.print("} else {\n"); + s4o.indent_right(); + symbol->else_statement_list->accept(*this); + s4o.indent_left(); + } + s4o.print(s4o.indent_spaces); s4o.print("}"); + return NULL; +} + +/* helper symbol for if_statement */ +void *visit(elseif_statement_list_c *symbol) {return print_list(symbol);} + +/* helper symbol for elseif_statement_list */ +void *visit(elseif_statement_c *symbol) { + s4o.print(s4o.indent_spaces); s4o.print("} else if ("); + symbol->expression->accept(*this); + s4o.print(") {\n"); + s4o.indent_right(); + symbol->statement_list->accept(*this); + s4o.indent_left(); + return NULL; +} + +void *visit(case_statement_c *symbol) { + s4o.print("switch("); + symbol->expression->accept(*this); + s4o.print(") {\n"); + s4o.indent_right(); + symbol->case_element_list->accept(*this); + if (symbol->statement_list != NULL) { + s4o.print(s4o.indent_spaces + "default:\n"); + s4o.indent_right(); + symbol->statement_list->accept(*this); + s4o.print(s4o.indent_spaces + "break;\n"); + s4o.indent_left(); + } + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "}"); + return NULL; +} + +/* helper symbol for case_statement */ +void *visit(case_element_list_c *symbol) {return print_list(symbol);} + +void *visit(case_element_c *symbol) { + s4o.print(s4o.indent_spaces + "case "); + symbol->case_list->accept(*this); + s4o.print(" :\n"); + s4o.indent_right(); + symbol->statement_list->accept(*this); + s4o.print(s4o.indent_spaces + "break;\n"); + s4o.indent_left(); + return NULL; +} + +void *visit(case_list_c *symbol) {return print_list(symbol, "", ", ");} + +/********************************/ +/* B 3.2.4 Iteration Statements */ +/********************************/ +void *visit(for_statement_c *symbol) { + s4o.print("for("); + symbol->control_variable->accept(*this); + s4o.print(" = "); + symbol->beg_expression->accept(*this); + s4o.print("; "); + symbol->control_variable->accept(*this); + s4o.print(" != "); + symbol->end_expression->accept(*this); + s4o.print("; "); + symbol->control_variable->accept(*this); + if (symbol->by_expression != NULL) { + s4o.print(" += "); + symbol->by_expression->accept(*this); + } else { + s4o.print("++"); + } + s4o.print(") {\n"); + s4o.indent_right(); + symbol->statement_list->accept(*this); + s4o.indent_left(); + s4o.print(s4o.indent_spaces); s4o.print("}"); + return NULL; +} +void *visit(while_statement_c *symbol) { + s4o.print("while ("); + symbol->expression->accept(*this); + s4o.print(") {\n"); + s4o.indent_right(); + symbol->statement_list->accept(*this); + s4o.indent_left(); + s4o.print(s4o.indent_spaces); s4o.print("}"); + return NULL; +} +void *visit(repeat_statement_c *symbol) { + s4o.print("do {\n"); + s4o.indent_right(); + symbol->statement_list->accept(*this); + s4o.indent_left(); + s4o.print(s4o.indent_spaces); s4o.print("} while("); + symbol->expression->accept(*this); + s4o.print(")"); + return NULL; +} +void *visit(exit_statement_c *symbol) { + s4o.print("exit(0)"); + return NULL; +} + + + +}; /* generate_c_st_c */ + + + + + + + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/generate_c_tempvardecl.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/generate_c_tempvardecl.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,179 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * Declare temporary variables to be later used as output parameters + * in function calls for which not all output parameters were + * defined in the original (st or il) source code. + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the IL and ST + * code. + */ + + + + +class temp_var_name_c { + private: + int counter; + + public: + void reset(void) {counter = 0;} + temp_var_name_c(void) {reset();} + + public: + std::string *new_name(void) { + std::string *new_str = new std::string(TEMP_VAR); + /* yikes!!! How to convert an int to a string elegantly??? + * Right now I (Mario) can only think of snprintf() + * C++ must have a more elegant method! + */ + int int_str_size = snprintf(NULL, 0, "%d", counter); + if (int_str_size <= 0) ERROR; + char *int_str = (char *)malloc(int_str_size+1); + if (snprintf(int_str, int_str_size+1, "%d", counter++) >= int_str_size+1) ERROR; + *new_str += int_str; + free(int_str); + return new_str; + } + +}; + + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + + + +/* Some function calls in the body of functions or function blocks + * may leave some parameters to their default values, and + * ignore some output parameters of the function being called. + * Our conversion of ST functions to C++ does not contemplate that, + * i.e. each called function must get all it's input and output + * parameters set correctly. + * For input parameters we merely need to call the function with + * the apropriate default value, but for output parameters + * we must create temporary variables to hold the output value. + * + * We declare all the temporary output variables at the begining of + * the body of each function or function block, and use them as + * in function calls later on as they become necessary... + * Note that we cannot create these variables just before a function + * call, as the function call itself may be integrated within an + * expression, or another function call! + * + * The variables are declared in the exact same order in which they + * will be used later on during the function calls, which allows us + * to simply re-create the name that was used for the temporary variable + * instead of keeping it in some list. + * The names are recreated by the temp_var_name_factory, after reset() + * has been called! + * + * This function will genertae code similar to... + * + * INT __TMP_0 = 23; + * REAL __TMP_1 = 45.5; + * ... + */ + +class generate_c_tempvardecl_c: generate_c_typedecl_c { + public: + generate_c_tempvardecl_c(stage4out_c *s4o_ptr): generate_c_typedecl_c(s4o_ptr) {} + + void generate(symbol_c *body, temp_var_name_c *temp_var_name_factory) { + temp_var_name_factory->reset(); + function_call_iterator_c fcall_iterator(body); + for(symbol_c *finvocation = NULL; (finvocation = fcall_iterator.next()) != NULL;) { + /* get the name of the next function that gets called */ + identifier_c *fcalled_name = fcall_iterator.fname(); + /* get that function's declaration... */ + function_declaration_c *fdecl = function_symtable.find_value(fcalled_name); + if (fdecl == function_symtable.end_value()) { + function_type_t function_type = get_function_type(fcalled_name); + if (function_type == function_none) ERROR; + return; + } + /* create iterator to iterate through each of the called function's parameters... */ + function_param_iterator_c fp_iterator(fdecl); + + /* iterate through each of the called function's parameters... */ + identifier_c *param_name = NULL; + function_call_param_iterator_c function_call_param_iterator(finvocation); + for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { + + function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); + if (param_direction == function_param_iterator_c::direction_in) + /* ignore input only parameters... + * we do not need to create temporary variables for these! + */ + continue; + + /* Get the value from a foo( = ) style call */ + symbol_c *param_value = function_call_param_iterator.search(param_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + + if (param_value != NULL) + /* ignore output parameters to which a variable is passed... + * we do not need to create temporary variables for these! + */ + continue; + + symbol_c *param_type = fp_iterator.param_type(); + + /* get the parameter's default value */ + param_value = fp_iterator.default_value(); + + /* If no default value specified in function declaration, + * get the default value of this variable's type + */ + if (param_value == NULL) + param_value = (symbol_c *)param_type->accept(*type_initial_value_c::instance()); + if (param_value == NULL) ERROR; + + /* now declare a temporary variable, with the correct default value... */ + s4o.print(s4o.indent_spaces); + param_type->accept(*this); + s4o.print(" "); + + std::string *temp_var_name = temp_var_name_factory->new_name(); + s4o.print(*temp_var_name); + delete temp_var_name; + + s4o.print(" = "); + param_value->accept(*this); + s4o.print(";\n"); + } + } + temp_var_name_factory->reset(); + s4o.print("\n"); + } +}; diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/generate_c_typedecl.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/generate_c_typedecl.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,467 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * Conversion of type declaration constructs. + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the IL and ST + * code. + */ + + + + + + +//#include /* required for NULL */ +//#include +//#include + +//#include "../../util/symtable.hh" + + + + + +class generate_c_typedecl_c: public generate_c_base_c { + + public: + generate_c_typedecl_c(stage4out_c *s4o_ptr): generate_c_base_c(s4o_ptr) {} + ~generate_c_typedecl_c(void) {} + + +/***************************/ +/* B 0 - Programming Model */ +/***************************/ + /* leave for derived classes... */ + +/*************************/ +/* B.1 - Common elements */ +/*************************/ +/*******************************************/ +/* B 1.1 - Letters, digits and identifiers */ +/*******************************************/ + /* done in base class(es) */ + +/*********************/ +/* B 1.2 - Constants */ +/*********************/ + /* originally empty... */ + +/******************************/ +/* B 1.2.1 - Numeric Literals */ +/******************************/ + /* done in base class(es) */ + +/*******************************/ +/* B.1.2.2 Character Strings */ +/*******************************/ + /* done in base class(es) */ + +/***************************/ +/* B 1.2.3 - Time Literals */ +/***************************/ +/************************/ +/* B 1.2.3.1 - Duration */ +/************************/ + /* done in base class(es) */ + +/************************************/ +/* B 1.2.3.2 - Time of day and Date */ +/************************************/ + /* done in base class(es) */ + +/**********************/ +/* B.1.3 - Data types */ +/**********************/ +/***********************************/ +/* B 1.3.1 - Elementary Data Types */ +/***********************************/ + /* done in base class(es) */ + +/********************************/ +/* B.1.3.2 - Generic data types */ +/********************************/ + /* originally empty... */ + +/********************************/ +/* B 1.3.3 - Derived data types */ +/********************************/ +void *visit(subrange_spec_init_c *symbol) { + TRACE("subrange_spec_init_c"); + // TODO... + ERROR; + return NULL; +} + +void *visit(enumerated_spec_init_c *symbol) { + TRACE("enumerated_spec_init_c"); + // TODO... + ERROR; + return NULL; +} + +/* TYPE type_declaration_list END_TYPE */ +void *visit(data_type_declaration_c *symbol) { + TRACE("data_type_declaration_c"); + symbol->type_declaration_list->accept(*this); + s4o.print("\n\n"); + return NULL; +} + +/* helper symbol for data_type_declaration */ +void *visit(type_declaration_list_c *symbol) { + TRACE("type_declaration_list_c"); + return print_list(symbol); +} + +/* simple_type_name ':' simple_spec_init */ +void *visit(simple_type_declaration_c *symbol) { + TRACE("simple_type_declaration_c"); + /* add this type declaration to the type symbol table... */ + type_symtable.insert(symbol->simple_type_name, symbol->simple_spec_init); + + s4o.print("typedef "); + symbol->simple_spec_init->accept(*this); + s4o.print(" "); + symbol->simple_type_name->accept(*this); + s4o.print(";\n"); + return NULL; +} + +/* simple_specification [ASSIGN constant] */ +//SYM_REF2(simple_spec_init_c, simple_specification, constant) +// may be NULL +void *visit(simple_spec_init_c *symbol) { + TRACE("simple_spec_init_c"); + symbol->simple_specification->accept(*this); + return NULL; +} + +#if 0 +/* subrange_type_name ':' subrange_spec_init */ +SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init) + +/* subrange_specification ASSIGN signed_integer */ +SYM_REF2(subrange_spec_init_c, subrange_specification, signed_integer) + +/* integer_type_name '(' subrange')' */ +SYM_REF2(subrange_specification_c, integer_type_name, subrange) + +/* signed_integer DOTDOT signed_integer */ +SYM_REF2(subrange_c, lower_limit, upper_limit) + +/* enumerated_type_name ':' enumerated_spec_init */ +SYM_REF2(enumerated_type_declaration_c, enumerated_type_name, enumerated_spec_init) + +/* enumerated_specification ASSIGN enumerated_value */ +SYM_REF2(enumerated_spec_init_c, enumerated_specification, enumerated_value) + +/* helper symbol for enumerated_specification->enumerated_spec_init */ +/* enumerated_value_list ',' enumerated_value */ +SYM_LIST(enumerated_value_list_c) + +/* enumerated_type_name '#' identifier */ +SYM_REF2(enumerated_value_c, type, value) + +/* identifier ':' array_spec_init */ +SYM_REF2(array_type_declaration_c, identifier, array_spec_init) + +/* array_specification [ASSIGN array_initialization} */ +/* array_initialization may be NULL ! */ +SYM_REF2(array_spec_init_c, array_specification, array_initialization) + +/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */ +SYM_REF2(array_specification_c, array_subrange_list, non_generic_type_name) + +/* helper symbol for array_specification */ +/* array_subrange_list ',' subrange */ +SYM_LIST(array_subrange_list_c) + +/* array_initialization: '[' array_initial_elements_list ']' */ +/* helper symbol for array_initialization */ +/* array_initial_elements_list ',' array_initial_elements */ +SYM_LIST(array_initial_elements_list_c) + +/* integer '(' [array_initial_element] ')' */ +/* array_initial_element may be NULL ! */ +SYM_REF2(array_initial_elements_c, integer, array_initial_element) +#endif + +/* structure_type_name ':' structure_specification */ +//SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification) +void *visit(structure_type_declaration_c *symbol) { + TRACE("structure_type_declaration_c"); + /* add this type declaration to the type symbol table... */ + type_symtable.insert(symbol->structure_type_name, symbol->structure_specification); + + s4o.print("typedef "); + symbol->structure_specification->accept(*this); + s4o.print(" "); + symbol->structure_type_name->accept(*this); + s4o.print(";\n"); + return NULL; +} + +/* structure_type_name ASSIGN structure_initialization */ +/* structure_initialization may be NULL ! */ +//SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization) +void *visit(initialized_structure_c *symbol) { + TRACE("initialized_structure_c"); + symbol->structure_type_name->accept(*this); + return NULL; +} + +/* helper symbol for structure_declaration */ +/* structure_declaration: STRUCT structure_element_declaration_list END_STRUCT */ +/* structure_element_declaration_list structure_element_declaration ';' */ +//SYM_LIST(structure_element_declaration_list_c) +void *visit(structure_element_declaration_list_c *symbol) { + TRACE("structure_element_declaration_list_c"); + s4o.print("struct {\n"); + s4o.indent_right(); + s4o.print(s4o.indent_spaces); + + print_list(symbol); + + s4o.indent_left(); + s4o.print(s4o.indent_spaces); + s4o.print("}"); + return NULL; +} + +/* structure_element_name ':' spec_init */ +//SYM_REF2(structure_element_declaration_c, structure_element_name, spec_init) +void *visit(structure_element_declaration_c *symbol) { + TRACE("structure_element_declaration_c"); + + symbol->spec_init->accept(*this); + s4o.print(" "); + symbol->structure_element_name->accept(*this); + s4o.print(";\n"); + s4o.print(s4o.indent_spaces); + + return NULL; +} + +/* helper symbol for structure_initialization */ +/* structure_initialization: '(' structure_element_initialization_list ')' */ +/* structure_element_initialization_list ',' structure_element_initialization */ +//SYM_LIST(structure_element_initialization_list_c) +void *visit(structure_element_initialization_list_c *symbol) { + TRACE("structure_element_initialization_list_c"); + + // TODO ??? + ERROR; + return NULL; +} + +/* structure_element_name ASSIGN value */ +//SYM_REF2(structure_element_initialization_c, structure_element_name, value) +void *visit(structure_element_initialization_c *symbol) { + TRACE("structure_element_initialization_c"); + + // TODO ??? + ERROR; + return NULL; +} + +#if 0 +/* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ +/* + * NOTE: + * (Summary: Contrary to what is expected, the + * string_type_declaration_c is not used to store + * simple string type declarations that do not include + * size limits. + * For e.g.: + * str1_type: STRING := "hello!" + * will be stored in a simple_type_declaration_c + * instead of a string_type_declaration_c. + * The following: + * str2_type: STRING [64] := "hello!" + * will be stored in a sring_type_declaration_c + * + * Read on for why this is done... + * End Summary) + * + * According to the spec, the valid construct + * TYPE new_str_type : STRING := "hello!"; END_TYPE + * has two possible routes to type_declaration... + * + * Route 1: + * type_declaration: single_element_type_declaration + * single_element_type_declaration: simple_type_declaration + * simple_type_declaration: identifier ':' simple_spec_init + * simple_spec_init: simple_specification ASSIGN constant + * (shift: identifier <- 'new_str_type') + * simple_specification: elementary_type_name + * elementary_type_name: STRING + * (shift: elementary_type_name <- STRING) + * (reduce: simple_specification <- elementary_type_name) + * (shift: constant <- "hello!") + * (reduce: simple_spec_init: simple_specification ASSIGN constant) + * (reduce: ...) + * + * + * Route 2: + * type_declaration: string_type_declaration + * string_type_declaration: identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init + * (shift: identifier <- 'new_str_type') + * elementary_string_type_name: STRING + * (shift: elementary_string_type_name <- STRING) + * (shift: string_type_declaration_size <- empty ) + * string_type_declaration_init: ASSIGN character_string + * (shift: character_string <- "hello!") + * (reduce: string_type_declaration_init <- ASSIGN character_string) + * (reduce: string_type_declaration <- identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init ) + * (reduce: type_declaration <- string_type_declaration) + * + * + * At first glance it seems that removing route 1 would make + * the most sense. Unfortunately the construct 'simple_spec_init' + * shows up multiple times in other rules, so changing this construct + * would also mean changing all the rules in which it appears. + * I (Mario) therefore chose to remove route 2 instead. This means + * that the above declaration gets stored in a + * simple_type_declaration_c, and not in a string_type_declaration_c + * as would be expected! + */ +/* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ +SYM_REF4(string_type_declaration_c, string_type_name, + elementary_string_type_name, + string_type_declaration_size, + string_type_declaration_init) /* may be == NULL! */ +#endif + +/*********************/ +/* B 1.4 - Variables */ +/*********************/ + /* done in base class(es) */ + +/********************************************/ +/* B.1.4.1 Directly Represented Variables */ +/********************************************/ +// direct_variable: direct_variable_token {$$ = new direct_variable_c($1);}; +void *visit(direct_variable_c *symbol) { + TRACE("direct_variable_c"); + /* Do not use print_token() as it will change everything into uppercase */ + if (strlen(symbol->value) == 0) ERROR; + return s4o.printlocation(symbol->value + 1); +} + + +/*************************************/ +/* B.1.4.2 Multi-element Variables */ +/*************************************/ + /* done in base class(es) */ + +/******************************************/ +/* B 1.4.3 - Declaration & Initialisation */ +/******************************************/ + /* leave for derived classes... */ + +/**************************************/ +/* B.1.5 - Program organization units */ +/**************************************/ +/***********************/ +/* B 1.5.1 - Functions */ +/***********************/ + /* leave for derived classes... */ + +/*****************************/ +/* B 1.5.2 - Function Blocks */ +/*****************************/ + /* leave for derived classes... */ + +/**********************/ +/* B 1.5.3 - Programs */ +/**********************/ + /* leave for derived classes... */ + +/*********************************************/ +/* B.1.6 Sequential function chart elements */ +/*********************************************/ + +/********************************/ +/* B 1.7 Configuration elements */ +/********************************/ + /* leave for derived classes... */ + +/****************************************/ +/* B.2 - Language IL (Instruction List) */ +/****************************************/ +/***********************************/ +/* B 2.1 Instructions and Operands */ +/***********************************/ + /* leave for derived classes... */ + +/*******************/ +/* B 2.2 Operators */ +/*******************/ + /* leave for derived classes... */ + + +/***************************************/ +/* B.3 - Language ST (Structured Text) */ +/***************************************/ +/***********************/ +/* B 3.1 - Expressions */ +/***********************/ + /* leave for derived classes... */ + +/********************/ +/* B 3.2 Statements */ +/********************/ + /* leave for derived classes... */ + +/*********************************/ +/* B 3.2.1 Assignment Statements */ +/*********************************/ + /* leave for derived classes... */ + +/*****************************************/ +/* B 3.2.2 Subprogram Control Statements */ +/*****************************************/ + /* leave for derived classes... */ + +/********************************/ +/* B 3.2.3 Selection Statements */ +/********************************/ + /* leave for derived classes... */ + +/********************************/ +/* B 3.2.4 Iteration Statements */ +/********************************/ + /* leave for derived classes... */ + + + + +}; /* generate_c_typedecl_c */ + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/generate_c_vardecl.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/generate_c_vardecl.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,1702 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * Conversion of variable declaration constructs. + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the IL and ST + * code. + */ + + + + +//#include /* required for NULL */ +//#include +//#include + +//#include "../../util/symtable.hh" + + + + + + + + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + + + + +class generate_c_vardecl_c: protected generate_c_typedecl_c { + + /* A Helper class to the main class... */ + /* print a string, except the first time it is called */ + /* used to print the separator "," before each variable + * declaration, except the first... + * + * Needs to be done in a seperate class because this is called + * from within various locations within the code. + */ + class next_var_c { + private: + bool print_flag; + std::string str1, str2; + + next_var_c *embedded_scope; + + public: + next_var_c(std::string s1, std::string s2) { + str1 = s1; + str2 = s2; + print_flag = false; + embedded_scope = NULL; + } + + std::string get(void) { + if (NULL != embedded_scope) + return embedded_scope->get(); + + bool old_print_flag = print_flag; + print_flag = true; + if (!old_print_flag) + return str1; + else + return str2; + } + + /* Create a new next_var_c for an embedded scope. + * From now on, every call to get() will return the + * inner-most scope...! + */ + void push(std::string s1, std::string s2) { + if (NULL != embedded_scope) + return embedded_scope->push(s1, s2); + + embedded_scope = new next_var_c(s1, s2); + if (NULL == embedded_scope) + ERROR; + return; + } + + /* Remove the inner-most scope... */ + void pop(void) { + if (NULL != embedded_scope) + return embedded_scope->pop(); + + delete embedded_scope; + embedded_scope = NULL; + } + }; + + private: + /* used to generate the ',' separating the parameters in a function call */ + next_var_c *nv; + + + public: + /* the types of variables that need to be processed... */ + static const unsigned int none_vt = 0x0000; + static const unsigned int input_vt = 0x0001; // VAR_INPUT + static const unsigned int output_vt = 0x0002; // VAR_OUTPUT + static const unsigned int inoutput_vt = 0x0004; // VAR_IN_OUT + static const unsigned int private_vt = 0x0008; // VAR + static const unsigned int temp_vt = 0x0010; // VAR_TEMP + static const unsigned int external_vt = 0x0020; // VAR_EXTERNAL + static const unsigned int global_vt = 0x0040; // VAR_GLOBAL + // Globals declared inside a resource will not be declared + // unless global_vt is acompanied by resource_vt + static const unsigned int located_vt = 0x0080; // VAR AT + static const unsigned int program_vt = 0x0100; // PROGRAM (inside a configuration!) + // Programs declared inside a resource will not be declared + // unless program_vt is acompanied by resource_vt + + static const unsigned int resource_vt = 0x8000; // RESOURCE (inside a configuration!) + // This, just of itself, will not print out any declarations!! + // It must be acompanied by either program_vt and/or global_vt + + /* How variables should be declared: as local variables or + * variables within a function call interface. + * + * This will define the format of the output generated + * by this class. + * + * finterface_vf: function interface parameters + * e.g. f( int a, long b, real c ); + * --------------------- + * This class/function will produce the + * underlined code of the above examples, + * and no more!! + * + * localinit_vf: local declaration. Will include variable + * initialisation if it is not a located variable. + * e.g. + * int a = 9; + * long b = 99; + * real c = 99.9; + * + * local_vf: local declaration. Will NOT include variable + * initialisation. + * e.g. + * int a; + * long b; + * real c; + * + * init_vf: local initialisation without declaration. + * e.g. + * a = 9; + * b = 99; + * c = 99.9; + * + * constructorinit_vf: initialising of member variables... + * e.g. for a constructor... + * class_name_c(void) + * : a(9), b(99), c(99.9) { // code... } + * -------------------- + * This class/function will produce the + * underlined code of the above examples, + * and no more!! + * + * globalinit_vf: initialising of static c++ variables. These + * variables may have been declared as static inside + * a class, in which case the scope within which they were + * previously delcared must be passed as the second parameter + * to the print() function. + * + * e.g. + * __plc_pt_c START_P::loc = __plc_pt_c("I2"); + */ + typedef enum {finterface_vf, + local_vf, + localstatic_vf, + localinit_vf, + init_vf, + constructorinit_vf, + globalinit_vf + } varformat_t; + + + private: + /* variable used to store the types of variables that need to be processed... */ + /* Only set in the constructor...! */ + /* Will contain a set of values of generate_c_vardecl_c::XXXX_vt */ + unsigned int wanted_vartype; + /* variable used to store the type of variable currently being processed... */ + /* Will contain a single value of generate_c_vardecl_c::XXXX_vt */ + unsigned int current_vartype; + + /* How variables should be declared: as local variables or + * variables within a function interface... + */ + /* Only set in the constructor...! */ + varformat_t wanted_varformat; + + /* The number of variables already declared. */ + /* Used to declare 'void' in case no variables are declared in a function interface... */ + int finterface_var_count; + + + + /* Holds the references to the type and initial value + * of the variables currently being declared. + * Please read the comment under var1_init_decl_c for further + * details... + * + * We make an effort to keep these pointers pointing to NULL + * whenever we are outside the scope of variable declaration + * (i.e. when we are traversing a part of the parse tree which + * is not part of variable declaration) in order tio try to catch + * any bugs as soon as possible. + */ + symbol_c *current_var_type_symbol; + symbol_c *current_var_init_symbol; + void update_type_init(symbol_c *symbol /* a spec_init_c, subrange_spec_init_c, etc... */ ) { + this->current_var_type_symbol = spec_init_sperator_c::get_spec(symbol); + this->current_var_init_symbol = spec_init_sperator_c::get_init(symbol); + if (NULL == this->current_var_type_symbol) + ERROR; + if (NULL == this->current_var_init_symbol) { + /* We try to find the data type's default value... */ + this->current_var_init_symbol = (symbol_c *)this->current_var_type_symbol->accept(*type_initial_value_c::instance()); + /* Note that Function Block 'data types' do not have a default value, so we cannot abort if no default value is found! */ + /* + if (NULL == this->current_var_init_symbol) + ERROR; + */ + } + } + + void void_type_init(void) { + this->current_var_type_symbol = NULL; + this->current_var_init_symbol = NULL; + } + + /* Only used when wanted_varformat == globalinit_vf + * Holds a pointer to an identifier_c, which in turns contains + * the identifier of the scope within which the static member was + * declared. + */ + symbol_c *globalnamespace; + + /* Actually produce the output where variables are declared... */ + /* Note that located variables are the exception, they + * being declared in the located_var_decl_c visitor... + */ + void *declare_variables(symbol_c *symbol, bool is_fb = false) { + list_c *list = dynamic_cast(symbol); + /* should NEVER EVER occur!! */ + if (list == NULL) ERROR; + + /* now to produce the c equivalent... */ + if ((wanted_varformat == local_vf) || + (wanted_varformat == init_vf) || + (wanted_varformat == localinit_vf)) { + for(int i = 0; i < list->n; i++) { + s4o.print(s4o.indent_spaces); + if (wanted_varformat != init_vf) { + this->current_var_type_symbol->accept(*this); + s4o.print(" "); + } + print_variable_prefix(); + list->elements[i]->accept(*this); + if (wanted_varformat != local_vf) { + if (this->current_var_init_symbol != NULL) { + s4o.print(" = "); + this->current_var_init_symbol->accept(*this); + } + } + s4o.print(";\n"); + } + } + + if (wanted_varformat == finterface_vf) { + for(int i = 0; i < list->n; i++) { + finterface_var_count++; + s4o.print(nv->get()); + s4o.print("\n" + s4o.indent_spaces); + this->current_var_type_symbol->accept(*this); + if ((current_vartype & (output_vt | inoutput_vt)) != 0) + s4o.print(" &"); + else + s4o.print(" "); + list->elements[i]->accept(*this); + /* We do not print the initial value at function declaration! + * It is up to the caller to pass the correct default value + * if none is specified in the ST source code + */ + /* if (this->current_var_init_symbol != NULL) { + s4o.print(" = "); this->current_var_init_symbol->accept(*this);} + */ + } + } + + if (wanted_varformat == constructorinit_vf) { + for(int i = 0; i < list->n; i++) { + if (is_fb) { + s4o.print(nv->get()); + this->current_var_type_symbol->accept(*this); + s4o.print(FB_INIT_SUFFIX); + s4o.print("(&"); + this->print_variable_prefix(); + list->elements[i]->accept(*this); + s4o.print(");"); + } + else if (this->current_var_init_symbol != NULL) { + s4o.print(nv->get()); + this->print_variable_prefix(); + list->elements[i]->accept(*this); + s4o.print(" = "); + this->current_var_init_symbol->accept(*this); + s4o.print(";"); + } + } + } + + return NULL; + } + + + + + public: + generate_c_vardecl_c(stage4out_c *s4o_ptr, varformat_t varformat, unsigned int vartype) + : generate_c_typedecl_c(s4o_ptr) { + wanted_varformat = varformat; + wanted_vartype = vartype; + current_vartype = none_vt; + current_var_type_symbol = NULL; + current_var_init_symbol = NULL; + globalnamespace = NULL; + nv = NULL; + } + + ~generate_c_vardecl_c(void) {} + + + void print(symbol_c *symbol, symbol_c *scope = NULL, const char *variable_prefix = NULL) { + this->set_variable_prefix(variable_prefix); + if (globalinit_vf == wanted_varformat) + globalnamespace = scope; + + finterface_var_count = 0; + + switch (wanted_varformat) { + case constructorinit_vf: nv = new next_var_c("", "\n"+s4o.indent_spaces); break; + case finterface_vf: /* fall through... */ + case localinit_vf: /* fall through... */ + case local_vf: nv = new next_var_c("", ", "); break; + default: nv = NULL; + } /* switch() */ + + symbol->accept(*this); + + /* special case... */ + if (wanted_varformat == finterface_vf) + if (finterface_var_count == 0) + s4o.print("void"); + + delete nv; + nv = NULL; + globalnamespace = NULL; + } + + + protected: +/***************************/ +/* B 0 - Programming Model */ +/***************************/ + /* leave for derived classes... */ + +/*************************/ +/* B.1 - Common elements */ +/*************************/ +/*******************************************/ +/* B 1.1 - Letters, digits and identifiers */ +/*******************************************/ + /* done in base class(es) */ + +/*********************/ +/* B 1.2 - Constants */ +/*********************/ + /* originally empty... */ + +/******************************/ +/* B 1.2.1 - Numeric Literals */ +/******************************/ + /* done in base class(es) */ + +/*******************************/ +/* B.1.2.2 Character Strings */ +/*******************************/ + /* done in base class(es) */ + +/***************************/ +/* B 1.2.3 - Time Literals */ +/***************************/ +/************************/ +/* B 1.2.3.1 - Duration */ +/************************/ + /* done in base class(es) */ + +/************************************/ +/* B 1.2.3.2 - Time of day and Date */ +/************************************/ + /* done in base class(es) */ + +/**********************/ +/* B.1.3 - Data types */ +/**********************/ +/***********************************/ +/* B 1.3.1 - Elementary Data Types */ +/***********************************/ + /* done in base class(es) */ + +/********************************/ +/* B.1.3.2 - Generic data types */ +/********************************/ + /* originally empty... */ + +/********************************/ +/* B 1.3.3 - Derived data types */ +/********************************/ + /* done in base class(es) */ + +/*********************/ +/* B 1.4 - Variables */ +/*********************/ + /* done in base class(es) */ + +/********************************************/ +/* B.1.4.1 Directly Represented Variables */ +/********************************************/ + /* done in base class(es) */ + +/*************************************/ +/* B.1.4.2 Multi-element Variables */ +/*************************************/ + /* done in base class(es) */ + +/******************************************/ +/* B 1.4.3 - Declaration & Initialisation */ +/******************************************/ +void *visit(constant_option_c *symbol) {s4o.print("CONSTANT"); return NULL;} +void *visit(retain_option_c *symbol) {s4o.print("RETAIN"); return NULL;} +void *visit(non_retain_option_c *symbol) {s4o.print("NON_RETAIN"); return NULL;} + +void *visit(input_declarations_c *symbol) { + TRACE("input_declarations_c"); + if ((wanted_vartype & input_vt) != 0) { +/* + // TO DO ... + if (symbol->option != NULL) + symbol->option->accept(*this); +*/ + //s4o.indent_right(); + current_vartype = input_vt; + symbol->input_declaration_list->accept(*this); + current_vartype = none_vt; + //s4o.indent_left(); + } + return NULL; +} + +/* helper symbol for input_declarations */ +void *visit(input_declaration_list_c *symbol) { + TRACE("input_declaration_list_c"); + print_list(symbol); + return NULL; +} + +void *visit(edge_declaration_c *symbol) { + TRACE("edge_declaration_c"); + // TO DO ... + symbol->var1_list->accept(*this); + s4o.print(" : BOOL "); + symbol->edge->accept(*this); + return NULL; +} + +void *visit(raising_edge_option_c *symbol) { + // TO DO ... + s4o.print("R_EDGE"); + return NULL; +} + + +#if 0 +/* var1_list ':' array_spec_init */ +SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init) +#endif + +/* var1_list ':' initialized_structure */ +// SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure) +void *visit(structured_var_init_decl_c *symbol) { + TRACE("structured_var_init_decl_c"); + /* Please read the comments inside the var1_init_decl_c + * visitor, as they apply here too. + */ + + /* Start off by setting the current_var_type_symbol and + * current_var_init_symbol private variables... + */ + update_type_init(symbol->initialized_structure); + + /* now to produce the c equivalent... */ + symbol->var1_list->accept(*this); + + /* Values no longer in scope, and therefore no longer used. + * Make an effort to keep them set to NULL when not in use + * in order to catch bugs as soon as possible... + */ + void_type_init(); + + return NULL; +} + +/* fb_name_list ':' function_block_type_name ASSIGN structure_initialization */ +/* structure_initialization -> may be NULL ! */ +void *visit(fb_name_decl_c *symbol) { + TRACE("fb_name_decl_c"); + /* Please read the comments inside the var1_init_decl_c + * visitor, as they apply here too. + */ + + /* Start off by setting the current_var_type_symbol and + * current_var_init_symbol private variables... + */ + update_type_init(symbol); + + /* now to produce the c equivalent... */ + symbol->fb_name_list->accept(*this); + + /* Values no longer in scope, and therefore no longer used. + * Make an effort to keep them set to NULL when not in use + * in order to catch bugs as soon as possible... + */ + void_type_init(); + + return NULL; +} + +/* fb_name_list ',' fb_name */ +void *visit(fb_name_list_c *symbol) { + TRACE("fb_name_list_c"); + declare_variables(symbol, true); + return NULL; +} + + +/* VAR_OUTPUT [RETAIN | NON_RETAIN] var_init_decl_list END_VAR */ +/* option -> may be NULL ! */ +void *visit(output_declarations_c *symbol) { + TRACE("output_declarations_c"); + if ((wanted_vartype & output_vt) != 0) { +/* + // TO DO ... + if (symbol->option != NULL) + symbol->option->accept(*this); +*/ + //s4o.indent_right(); + current_vartype = output_vt; + symbol->var_init_decl_list->accept(*this); + current_vartype = none_vt; + //s4o.indent_left(); + } + return NULL; +} + +/* VAR_IN_OUT var_declaration_list END_VAR */ +void *visit(input_output_declarations_c *symbol) { + TRACE("input_output_declarations_c"); + if ((wanted_vartype & inoutput_vt) != 0) { + //s4o.indent_right(); + current_vartype = inoutput_vt; + symbol->var_declaration_list->accept(*this); + current_vartype = none_vt; + //s4o.indent_left(); + } + return NULL; +} + +/* helper symbol for input_output_declarations */ +/* var_declaration_list var_declaration ';' */ +void *visit(var_declaration_list_c *symbol) { + TRACE("var_declaration_list_c"); + print_list(symbol); + return NULL; +} + +#if 0 +/* var1_list ':' array_specification */ +SYM_REF2(array_var_declaration_c, var1_list, array_specification) +#endif + +/* var1_list ':' structure_type_name */ +//SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name) +void *visit(structured_var_declaration_c *symbol) { + TRACE("structured_var_declaration_c"); + /* Please read the comments inside the var1_init_decl_c + * visitor, as they apply here too. + */ + + /* Start off by setting the current_var_type_symbol and + * current_var_init_symbol private variables... + */ + update_type_init(symbol->structure_type_name); + + /* now to produce the c equivalent... */ + symbol->var1_list->accept(*this); + + /* Values no longer in scope, and therefore no longer used. + * Make an effort to keep them set to NULL when not in use + * in order to catch bugs as soon as possible... + */ + void_type_init(); + + return NULL; +} + + +/* VAR [CONSTANT] var_init_decl_list END_VAR */ +/* option -> may be NULL ! */ +/* helper symbol for input_declarations */ +void *visit(var_declarations_c *symbol) { + TRACE("var_declarations_c"); + if ((wanted_vartype & private_vt) != 0) { +/* + // TO DO ... + if (symbol->option != NULL) + symbol->option->accept(*this); +*/ + current_vartype = private_vt; + symbol->var_init_decl_list->accept(*this); + current_vartype = none_vt; + } + return NULL; +} + +/* VAR RETAIN var_init_decl_list END_VAR */ +void *visit(retentive_var_declarations_c *symbol) { + TRACE("retentive_var_declarations_c"); + if ((wanted_vartype & private_vt) != 0) { + current_vartype = private_vt; + symbol->var_init_decl_list->accept(*this); + current_vartype = none_vt; + } + return NULL; +} + +/* VAR [CONSTANT|RETAIN|NON_RETAIN] located_var_decl_list END_VAR */ +/* option -> may be NULL ! */ +//SYM_REF2(located_var_declarations_c, option, located_var_decl_list) +void *visit(located_var_declarations_c *symbol) { + TRACE("located_var_declarations_c"); + if ((wanted_vartype & located_vt) != 0) { +/* + // TO DO ... + if (symbol->option != NULL) + symbol->option->accept(*this); +*/ + current_vartype = located_vt; + symbol->located_var_decl_list->accept(*this); + current_vartype = none_vt; + } + return NULL; +} + +/* helper symbol for located_var_declarations */ +/* located_var_decl_list located_var_decl ';' */ +//SYM_LIST(located_var_decl_list_c) +void *visit(located_var_decl_list_c *symbol) { + TRACE("located_var_decl_list_c"); + print_list(symbol); + return NULL; +} + + +/* [variable_name] location ':' located_var_spec_init */ +/* variable_name -> may be NULL ! */ +//SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused) +void *visit(located_var_decl_c *symbol) { + TRACE("located_var_decl_c"); + /* Please read the comments inside the var1_init_decl_c + * visitor, as they apply here too. + */ + + /* Start off by setting the current_var_type_symbol and + * current_var_init_symbol private variables... + */ + update_type_init(symbol->located_var_spec_init); + + /* now to produce the c equivalent... */ + switch(wanted_varformat) { + case local_vf: + s4o.print(s4o.indent_spaces); + this->current_var_type_symbol->accept(*this); + s4o.print(" *"); + if (symbol->variable_name != NULL) + symbol->variable_name->accept(*this); + else + symbol->location->accept(*this); + s4o.print(";\n"); + break; + + case constructorinit_vf: + s4o.print(nv->get()); + s4o.print("{extern "); + this->current_var_type_symbol->accept(*this); + s4o.print(" "); + symbol->location->accept(*this); + s4o.print("; "); + print_variable_prefix(); + if (symbol->variable_name != NULL) + symbol->variable_name->accept(*this); + else + symbol->location->accept(*this); + s4o.print(" = &"); + symbol->location->accept(*this); + s4o.print(";}"); + break; + + case globalinit_vf: + s4o.print(s4o.indent_spaces + "__plc_pt_c<"); + this->current_var_type_symbol->accept(*this); + s4o.print(", 8*sizeof("); + this->current_var_type_symbol->accept(*this); + s4o.print(")> "); + if (this->globalnamespace != NULL) { + this->globalnamespace->accept(*this); + s4o.print("::"); + } + if (symbol->variable_name != NULL) + symbol->variable_name->accept(*this); + else + symbol->location->accept(*this); + + s4o.print(" = "); + + s4o.print(s4o.indent_spaces + "__plc_pt_c<"); + this->current_var_type_symbol->accept(*this); + s4o.print(", 8*sizeof("); + this->current_var_type_symbol->accept(*this); + s4o.print(")>(\""); + symbol->location->accept(*this); + s4o.print("\""); + if (this->current_var_init_symbol != NULL) { + s4o.print(", "); + this->current_var_init_symbol->accept(*this); + } + s4o.print(");\n"); + break; + + default: + ERROR; + } /* switch() */ + + /* Values no longer in scope, and therefore no longer used. + * Make an effort to keep them set to NULL when not in use + * in order to catch bugs as soon as possible... + */ + void_type_init(); + + return NULL; +} + + + + +/*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */ +/* option -> may be NULL ! */ +//SYM_REF2(external_var_declarations_c, option, external_declaration_list) +void *visit(external_var_declarations_c *symbol) { + TRACE("external_var_declarations_c"); + if ((wanted_vartype & external_vt) != 0) { +/* + // TODO ... + if (symbol->option != NULL) + symbol->option->accept(*this); +*/ + //s4o.indent_right(); + current_vartype = external_vt; + symbol->external_declaration_list->accept(*this); + current_vartype = none_vt; + //s4o.indent_left(); + } + return NULL; +} + +/* helper symbol for external_var_declarations */ +/*| external_declaration_list external_declaration';' */ +//SYM_LIST(external_declaration_list_c) +/* helper symbol for input_declarations */ +void *visit(external_declaration_list_c *symbol) { + TRACE("external_declaration_list_c"); + print_list(symbol); + return NULL; +} + + +/* global_var_name ':' (simple_specification|subrange_specification|enumerated_specification|array_specification|prev_declared_structure_type_name|function_block_type_name */ +//SYM_REF2(external_declaration_c, global_var_name, specification) +void *visit(external_declaration_c *symbol) { + TRACE("external_declaration_c"); + /* Please read the comments inside the var1_init_decl_c + * visitor, as they apply here too. + */ + + /* Start off by setting the current_var_type_symbol and + * current_var_init_symbol private variables... + */ + this->current_var_type_symbol = symbol->specification; + this->current_var_init_symbol = NULL; + + /* now to produce the c equivalent... */ + switch (wanted_varformat) { + case local_vf: + case localinit_vf: + s4o.print(s4o.indent_spaces); + this->current_var_type_symbol->accept(*this); + s4o.print(" *"); + symbol->global_var_name->accept(*this); + if ((wanted_varformat == localinit_vf) && + (this->current_var_init_symbol != NULL)) { + s4o.print(" = "); + this->current_var_init_symbol->accept(*this); + } + s4o.print(";\n"); + break; + + case constructorinit_vf: + s4o.print(nv->get()); + s4o.print("{extern "); + this->current_var_type_symbol->accept(*this); + s4o.print(" *"); + symbol->global_var_name->accept(*this); + s4o.print("; "); + print_variable_prefix(); + symbol->global_var_name->accept(*this); + s4o.print(" = "); + symbol->global_var_name->accept(*this); + s4o.print(";}"); + break; + + case finterface_vf: + finterface_var_count++; + s4o.print(nv->get()); + this->current_var_type_symbol->accept(*this); + s4o.print(" *"); + symbol->global_var_name->accept(*this); + break; + + default: + ERROR; + } + + /* Values no longer in scope, and therefore no longer used. + * Make an effort to keep them set to NULL when not in use + * in order to catch bugs as soon as possible... + */ + void_type_init(); + + return NULL; +} + + + +/*| VAR_GLOBAL [CONSTANT|RETAIN] global_var_decl_list END_VAR */ +/* option -> may be NULL ! */ +// SYM_REF2(global_var_declarations_c, option, global_var_decl_list) +void *visit(global_var_declarations_c *symbol) { + TRACE("global_var_declarations_c"); + if ((wanted_vartype & global_vt) != 0) { +/* + // TODO ... + if (symbol->option != NULL) + symbol->option->accept(*this); +*/ + //s4o.indent_right(); + unsigned int previous_vartype = current_vartype; + // previous_vartype will be either none_vt, or resource_vt + current_vartype = global_vt; + symbol->global_var_decl_list->accept(*this); + current_vartype = previous_vartype; + //s4o.indent_left(); + } + return NULL; +} + +/* helper symbol for global_var_declarations */ +/*| global_var_decl_list global_var_decl ';' */ +//SYM_LIST(global_var_decl_list_c) +void *visit(global_var_decl_list_c *symbol) { + TRACE("global_var_decl_list_c"); + print_list(symbol); + return NULL; +} + + + +/*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */ +/* type_specification ->may be NULL ! */ +// SYM_REF2(global_var_decl_c, global_var_spec, type_specification) +void *visit(global_var_decl_c *symbol) { + TRACE("global_var_decl_c"); + /* Please read the comments inside the var1_init_decl_c + * visitor, as they apply here too. + */ + + /* Start off by setting the current_var_type_symbol and + * current_var_init_symbol private variables... + */ + update_type_init(symbol->type_specification); + + /* now to produce the c equivalent... */ + symbol->global_var_spec->accept(*this); + + /* Values no longer in scope, and therefore no longer used. + * Make an effort to keep them set to NULL when not in use + * in order to catch bugs as soon as possible... + */ + void_type_init(); + + return NULL; +} + + +/*| global_var_name location */ +// SYM_REF2(global_var_spec_c, global_var_name, location) +void *visit(global_var_spec_c *symbol) { + TRACE("global_var_spec_c"); + + /* now to produce the c equivalent... */ + switch(wanted_varformat) { + case local_vf: + case localstatic_vf: + /* NOTE: located variables must be declared static, as the connection to the + * MatPLC point must be initialised at program startup, and not whenever + * a new function block is instantiated! + * Nevertheless, this construct never occurs inside a Function Block, but + * only inside a configuration. In this case, only a single instance will + * be created, directly at startup, so it is not necessary that the variables + * be declared static. + */ + s4o.print(s4o.indent_spaces); + if (symbol->global_var_name != NULL) { + s4o.print("extern "); + this->current_var_type_symbol->accept(*this); + s4o.print(" "); + symbol->location->accept(*this); + s4o.print(";\n"); + if (wanted_varformat == localstatic_vf) + s4o.print("static "); + this->current_var_type_symbol->accept(*this); + s4o.print(" *"); + symbol->global_var_name->accept(*this); + s4o.print(" = &"); + symbol->location->accept(*this); + s4o.print(";\n"); + } + break; + + case constructorinit_vf: + s4o.print(nv->get()); + + if (symbol->global_var_name != NULL) { + s4o.print("*"); + symbol->global_var_name->accept(*this); + } + else + symbol->location->accept(*this); + s4o.print(" = "); + if (this->current_var_init_symbol != NULL) { + this->current_var_init_symbol->accept(*this); + } + s4o.print(";"); + break; + + default: + ERROR; + } /* switch() */ + + return NULL; +} + + + +/* AT direct_variable */ +// SYM_REF2(location_c, direct_variable, unused) +void *visit(location_c *symbol) { + TRACE("location_c"); + return symbol->direct_variable->accept(*this); +} + + +/*| global_var_list ',' global_var_name */ +//SYM_LIST(global_var_list_c) +void *visit(global_var_list_c *symbol) { + TRACE("global_var_list_c"); + list_c *list = dynamic_cast(symbol); + /* should NEVER EVER occur!! */ + if (list == NULL) ERROR; + + /* now to produce the c equivalent... */ + switch (wanted_varformat) { + case local_vf: + case localinit_vf: + for(int i = 0; i < list->n; i++) { + s4o.print(s4o.indent_spaces); + this->current_var_type_symbol->accept(*this); + s4o.print(" __"); + list->elements[i]->accept(*this); + s4o.print(";\n"); + this->current_var_type_symbol->accept(*this); + s4o.print(" *"); + list->elements[i]->accept(*this); + s4o.print(" = &__"); + list->elements[i]->accept(*this); +#if 0 + if (wanted_varformat == localinit_vf) { + if (this->current_var_init_symbol != NULL) { + s4o.print(" = "); + this->current_var_init_symbol->accept(*this); + } + } +#endif + s4o.print(";\n"); + } + break; + + case constructorinit_vf: + if (this->current_var_init_symbol != NULL) { + for(int i = 0; i < list->n; i++) { + s4o.print(nv->get()); + + s4o.print("*"); + list->elements[i]->accept(*this); + s4o.print(" = "); + this->current_var_init_symbol->accept(*this); + s4o.print(";"); +#if 0 + /* The following code would be for globalinit_vf !! + * But it is not currently required... + */ + s4o.print(s4o.indent_spaces + "__ext_element_c<"); + this->current_var_type_symbol->accept(*this); + s4o.print("> "); + if (this->globalnamespace != NULL) { + this->globalnamespace->accept(*this); + s4o.print("::"); + } + list->elements[i]->accept(*this); + + if (this->current_var_init_symbol != NULL) { + s4o.print(" = "); + s4o.print("__ext_element_c<"); + this->current_var_type_symbol->accept(*this); + s4o.print(">("); + this->current_var_init_symbol->accept(*this); + s4o.print(")"); + } + s4o.print(";\n"); +#endif + } + } + break; + + default: + ERROR; /* not supported, and not needed either... */ + } + + return NULL; +} + + +#if 0 +/* var1_list ':' single_byte_string_spec */ +SYM_REF2(single_byte_string_var_declaration_c, var1_list, single_byte_string_spec) + +/* STRING ['[' integer ']'] [ASSIGN single_byte_character_string] */ +/* integer ->may be NULL ! */ +/* single_byte_character_string ->may be NULL ! */ +SYM_REF2(single_byte_string_spec_c, integer, single_byte_character_string) + +/* var1_list ':' double_byte_string_spec */ +SYM_REF2(double_byte_string_var_declaration_c, var1_list, double_byte_string_spec) + +/* WSTRING ['[' integer ']'] [ASSIGN double_byte_character_string] */ +/* integer ->may be NULL ! */ +/* double_byte_character_string ->may be NULL ! */ +SYM_REF2(double_byte_string_spec_c, integer, double_byte_character_string) + +/*| VAR [RETAIN|NON_RETAIN] incompl_located_var_decl_list END_VAR */ +/* option ->may be NULL ! */ +SYM_REF2(incompl_located_var_declarations_c, option, incompl_located_var_decl_list) + +/* helper symbol for incompl_located_var_declarations */ +/*| incompl_located_var_decl_list incompl_located_var_decl ';' */ +SYM_LIST(incompl_located_var_decl_list_c) + +/* variable_name incompl_location ':' var_spec */ +SYM_REF4(incompl_located_var_decl_c, variable_name, incompl_location, var_spec, unused) + +/* AT incompl_location_token */ +SYM_TOKEN(incompl_location_c) +#endif + + +void *visit(falling_edge_option_c *symbol) { + // TO DO ... + s4o.print("F_EDGE"); + return NULL; +} + + +void *visit(var1_init_decl_c *symbol) { + TRACE("var1_init_decl_c"); + /* We have several implementation alternatives here... + * + * The issue is that generation of c code + * based on the abstract syntax tree requires the reversal + * of the symbol order compared to st. For e.g.: + * (ST) a, b, c: INT := 98; + * (C ) int a=98, b=98, c=98; + * The spec_init contains the references to 'INT' and '98'. + * The var1_list contains the references to 'a', 'b', and 'c'. + * The var1_init_decl_c contains the references to spec_init and var1_list. + * + * For c code generation, the var1_init_decl_c visitor + * would need to access the internals of other classes + * (e.g. the simple_spec_init_c). + * + * We can do this using one of three methods: + * 1) Create the abstract syntax tree differently; + * 2) Access other classes from within the var1_init_decl_c; + * 3) Pass info between the visitors using global variables + * only acessible by this class (private vars) + * + * In 1), the abstract syntax tree would be built so that + * var1_init_decl_c would contain direct references to + * var1_list_c, to the var type 'INT' and to the initialiser '98' + * (as per the example above). + * + * 2) would have several sub-options to obtain the references + * to 'INT' and '98' from within var1_init_decl_c. + * In 2a), the var1_init_decl_c would use dynamic casts to determine + * the class of spec_init (simple_spec_init_c, subrange_spec_init_c or + * enumerated_spec_init_c), and from there obtain the 'INT' and '98' + * In 2b) var1_init_decl_c would have one reference for each + * simple_spec_init_c, subrange_spec_init_c and enumerated_spec_init_c, + * the apropriate one being initialised by the var1_init_decl_c constructor. + * Note that the constructor would use dynamic casts. In essence, we + * would merely be changing the location of the code with the + * dynamic casts. + * In 2c) we would use three overloaded constructors for var1_init_decl_c + * one each for simple_spec_init_c, etc... This implies + * use type specific pointers to each symbol in the bison + * parser, instead of simply using a symbol_c * for all symbols; + * + * In 3), we use two global but private variables with references to + * 'INT' and '98', that would be initiliased by the visitors to + * simple_spec_init_c, subrange_spec_init_c and enumerated_spec_init_c. + * The visitor to var1_list_c would then use the references in the global + * variables. + * + * I (Mario) have chosen to use 3). + */ + + /* Start off by setting the current_var_type_symbol and + * current_var_init_symbol private variables... + */ + update_type_init(symbol->spec_init); + + /* now to produce the c equivalent... */ + symbol->var1_list->accept(*this); + + /* Values no longer in scope, and therefore no longer used. + * Make an effort to keep them set to NULL when not in use + * in order to catch bugs as soon as possible... + */ + void_type_init(); + + return NULL; +} + + + +void *visit(var1_list_c *symbol) { + TRACE("var1_list_c"); + declare_variables(symbol); + return NULL; +} + + + + +/* intermediate helper symbol for: + * - non_retentive_var_decls + * - output_declarations + */ +void *visit(var_init_decl_list_c *symbol) { + TRACE("var_init_decl_list_c"); + return print_list(symbol); + return NULL; +} + + +/**************************************/ +/* B.1.5 - Program organization units */ +/**************************************/ +/***********************/ +/* B 1.5.1 - Functions */ +/***********************/ +/* The missing function_declaration_c + * is handled in derived classes + */ + + + +/* intermediate helper symbol for function_declaration */ +void *visit(var_declarations_list_c *symbol) { + TRACE("var_declarations_list_c"); + return print_list(symbol); +} + + +void *visit(function_var_decls_c *symbol) { + TRACE("function_var_decls_c"); + + if ((wanted_vartype & private_vt) != 0) { +/* + // TO DO ... + if (symbol->option != NULL) + symbol->option->accept(*this); +*/ + current_vartype = private_vt; + symbol->decl_list->accept(*this); + current_vartype = none_vt; + } + return NULL; +} + + +/* intermediate helper symbol for function_var_decls */ +void *visit(var2_init_decl_list_c *symbol) { + TRACE("var2_init_decl_list_c"); + print_list(symbol); + return NULL; +} + + +/*****************************/ +/* B 1.5.2 - Function Blocks */ +/*****************************/ + +/* The missing function_block_declaration_c + * is handled in derived classes + */ + + +/* VAR_TEMP temp_var_decl_list END_VAR */ +void *visit(temp_var_decls_c *symbol) { + TRACE("temp_var_decls_c"); + if ((wanted_vartype & temp_vt) != 0) { + current_vartype = temp_vt; + symbol->var_decl_list->accept(*this); + current_vartype = none_vt; + } + return NULL; +} + +/* intermediate helper symbol for temp_var_decls */ +void *visit(temp_var_decls_list_c *symbol) { + TRACE("temp_var_decls_list_c"); + return print_list(symbol); +} + +/* VAR NON_RETAIN var_init_decl_list END_VAR */ +void *visit(non_retentive_var_decls_c *symbol) { + TRACE("non_retentive_var_decls_c"); + // TODO ... guarantee the non-retain semantics! + if ((wanted_vartype & private_vt) != 0) { + current_vartype = private_vt; + symbol->var_decl_list->accept(*this); + current_vartype = none_vt; + } + return NULL; +} + + + +/**********************/ +/* B 1.5.3 - Programs */ +/**********************/ + /* leave for derived classes... */ + +/*********************************************/ +/* B.1.6 Sequential function chart elements */ +/*********************************************/ + +/********************************/ +/* B 1.7 Configuration elements */ +/********************************/ + /* Programs instantiated inside configurations are declared as variables!! */ + +/* +CONFIGURATION configuration_name + optional_global_var_declarations + (resource_declaration_list | single_resource_declaration) + optional_access_declarations + optional_instance_specific_initializations +END_CONFIGURATION +*/ +/* +SYM_REF6(configuration_declaration_c, configuration_name, global_var_declarations, resource_declarations, access_declarations, instance_specific_initializations, unused) +*/ +void *visit(configuration_declaration_c *symbol) { + TRACE("configuration_declaration_c"); + + if(symbol->global_var_declarations) + symbol->global_var_declarations->accept(*this); // will contain VAR_GLOBAL declarations!! + symbol->resource_declarations->accept(*this); // will contain PROGRAM declarations!! + return NULL; +} + + +/* helper symbol for configuration_declaration */ +// SYM_LIST(resource_declaration_list_c) +void *visit(resource_declaration_list_c *symbol) { + TRACE("resource_declaration_list_c"); + + return print_list(symbol); +} + +/* +RESOURCE resource_name ON resource_type_name + optional_global_var_declarations + single_resource_declaration +END_RESOURCE +*/ +// SYM_REF4(resource_declaration_c, resource_name, resource_type_name, global_var_declarations, resource_declaration) +void *visit(resource_declaration_c *symbol) { + TRACE("resource_declaration_c"); + + if ((wanted_vartype & resource_vt) != 0) { + s4o.print(s4o.indent_spaces + "struct {\n"); + s4o.indent_right(); + + current_vartype = resource_vt; + if (NULL != symbol->global_var_declarations) + symbol->global_var_declarations->accept(*this); // will contain VAR_GLOBAL declarations!! + if (NULL != symbol->resource_declaration) + symbol->resource_declaration->accept(*this); // will contain PROGRAM declarations!! + current_vartype = none_vt; + + s4o.indent_left(); + s4o.print(s4o.indent_spaces + "} "); + symbol->resource_name->accept(*this); + s4o.print(";\n"); + } + return NULL; +} + +/* task_configuration_list program_configuration_list */ +// SYM_REF2(single_resource_declaration_c, task_configuration_list, program_configuration_list) +void *visit(single_resource_declaration_c *symbol) { + TRACE("single_resource_declaration_c"); + + if ((wanted_vartype & program_vt) != 0) { + unsigned int previous_vartype = current_vartype; + // previous_vartype will be resource_vt + current_vartype = program_vt; + symbol->program_configuration_list->accept(*this); + current_vartype = previous_vartype; + } + return NULL; +} + + +/* helper symbol for single_resource_declaration */ +// SYM_LIST(task_configuration_list_c) + + +/* helper symbol for single_resource_declaration */ +/* | program_configuration_list program_configuration ';' */ +// SYM_LIST(program_configuration_list_c) +void *visit(program_configuration_list_c *symbol) { + TRACE("program_configuration_list_c"); + + return print_list(symbol); +} + +/* helper symbol for + * - access_path + * - instance_specific_init + */ +// SYM_LIST(any_fb_name_list_c) + +/* [resource_name '.'] global_var_name ['.' structure_element_name] */ +// SYM_REF4(global_var_reference_c, resource_name, global_var_name, structure_element_name, unused) + +/* prev_declared_program_name '.' symbolic_variable */ +// SYM_REF2(program_output_reference_c, program_name, symbolic_variable) + +/* TASK task_name task_initialization */ +// SYM_REF2(task_configuration_c, task_name, task_initialization) + +/* '(' [SINGLE ASSIGN data_source ','] [INTERVAL ASSIGN data_source ','] PRIORITY ASSIGN integer ')' */ +// SYM_REF4(task_initialization_c, single_data_source, interval_data_source, priority_data_source, unused) + +/* PROGRAM [RETAIN | NON_RETAIN] program_name [WITH task_name] ':' program_type_name ['(' prog_conf_elements ')'] */ +// SYM_REF6(program_configuration_c, retain_option, program_name, task_name, program_type_name, prog_conf_elements, unused) +private: + /* a helper function to the program_configuration_c visitor... */ + void program_constructor_call(program_configuration_c *symbol) { + program_declaration_c *p_decl = program_type_symtable.find_value(symbol->program_type_name); + + if (p_decl == program_type_symtable.end_value()) + /* should never occur. The program being called MUST be in the symtable... */ + ERROR; + + symbol->program_name->accept(*this); + s4o.print("("); + + /* loop through each function parameter, find the value we should pass + * to it, and then output the c equivalent... + */ + function_param_iterator_c fp_iterator(p_decl); + function_call_param_iterator_c function_call_param_iterator(symbol); + identifier_c *param_name; + nv->push("", ", "); + for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { + + symbol_c *param_type = fp_iterator.param_type(); + if (param_type == NULL) ERROR; + + function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); + +#if 0 + /* Get the value from a foo( = ) style call */ + symbol_c *param_value = function_call_param_iterator.search(param_name); +#endif + + switch (param_direction) { + case function_param_iterator_c::direction_in: + case function_param_iterator_c::direction_out: + case function_param_iterator_c::direction_inout: + /* ignore them all!! */ + break; + + case function_param_iterator_c::direction_extref: +#if 0 + if (param_value == NULL) + /* This is illegal in ST and IL languages. + * All variables declared in a VAR_EXTERNAL __must__ + * be initialised to reference a specific VAR_GLOBAL variable!! + * + * The semantic checker should have caught this, we check again just the + * same (especially since the semantic checker has not yet been written!). + */ + ERROR; + s4o.print(nv->get()); + s4o.print("&"); + param_value->accept(*this); +#endif + break; +#if 0 + if (param_value == NULL) { + /* no parameter value given, so we pass a previously declared temporary variable. */ + std::string *temp_var_name = temp_var_name_factory.new_name(); + s4o.print(*temp_var_name); + delete temp_var_name; + } else { + param_value->accept(*this); + } +#endif + break; + } /* switch */ + } /* for(...) */ + + // symbol->parameter_assignment->accept(*this); + s4o.print(")"); + nv->pop(); + return; +} + + +public: +void *visit(program_configuration_c *symbol) { + TRACE("program_configuration_c"); + + /* now to produce the c equivalent... */ + switch (wanted_varformat) { + case local_vf: + case localinit_vf: + s4o.print(s4o.indent_spaces); + symbol->program_type_name->accept(*this); + s4o.print(" "); + symbol->program_name->accept(*this); + if (wanted_varformat == localinit_vf) { + // TODO... + // program_call(symbol); + } + s4o.print(";\n"); + break; + + case constructorinit_vf: + s4o.print(nv->get()); + program_constructor_call(symbol); +/* + symbol->program_name->accept(*this); + s4o.print("("); + symbol->prog_conf_elements->accept(*this); + nv->pop(); + s4o.print(")"); +*/ + break; + + default: + ERROR; /* not supported, and not needed either... */ + } + + return NULL; +} + + + +/* prog_conf_elements ',' prog_conf_element */ +//SYM_LIST(prog_conf_elements_c) +void *visit(prog_conf_elements_c *symbol) { + TRACE("prog_conf_elements_c"); + + return print_list(symbol); +} + +/* fb_name WITH task_name */ +//SYM_REF2(fb_task_c, fb_name, task_name) +void *visit(fb_task_c *symbol) { + TRACE("fb_task_c"); + + /* TODO... + * + * NOTE: Not yet supported... + * We do not support allocating specific function blocks declared + * inside a program to be executed by a different task from the one + * already executing the program itself. + * This is mostly because I (Mario) simply do not understand the + * semantics the standard expects us to implement in this case. It is all + * very confusing, and very poorly defined in the standard! + */ + ERROR; + return NULL; +} + + + + + + + + + + + + + + + + + + + + + + + + + + + +/* any_symbolic_variable ASSIGN prog_data_source */ +// SYM_REF2(prog_cnxn_assign_c, symbolic_variable, prog_data_source) +void *visit(prog_cnxn_assign_c *symbol) { + TRACE("prog_cnxn_assign_c"); + + /* TODO... */ + return NULL; +} + +/* any_symbolic_variable SENDTO data_sink */ +// SYM_REF2(prog_cnxn_sendto_c, symbolic_variable, prog_data_source) +void *visit(prog_cnxn_sendto_c *symbol) { + TRACE("prog_cnxn_sendto_c"); + + /* TODO... */ + return NULL; +} + +#if 0 +/* VAR_CONFIG instance_specific_init_list END_VAR_BOGUS */ +SYM_REF2(instance_specific_initializations_c, instance_specific_init_list, unused) + +/* helper symbol for instance_specific_initializations */ +SYM_LIST(instance_specific_init_list_c) + +/* resource_name '.' program_name '.' {fb_name '.'} + ((variable_name [location] ':' located_var_spec_init) | (fb_name ':' fb_initialization)) +*/ +SYM_REF6(instance_specific_init_c, resource_name, program_name, any_fb_name_list, variable_name, location, initialization) + +/* helper symbol for instance_specific_init */ +/* function_block_type_name ':=' structure_initialization */ +SYM_REF2(fb_initialization_c, function_block_type_name, structure_initialization) + +#endif + + + + +/****************************************/ +/* B.2 - Language IL (Instruction List) */ +/****************************************/ +/***********************************/ +/* B 2.1 Instructions and Operands */ +/***********************************/ + /* leave for derived classes... */ + +/*******************/ +/* B 2.2 Operators */ +/*******************/ + /* leave for derived classes... */ + + +/***************************************/ +/* B.3 - Language ST (Structured Text) */ +/***************************************/ +/***********************/ +/* B 3.1 - Expressions */ +/***********************/ + /* leave for derived classes... */ + +/********************/ +/* B 3.2 Statements */ +/********************/ + /* leave for derived classes... */ + +/*********************************/ +/* B 3.2.1 Assignment Statements */ +/*********************************/ + /* leave for derived classes... */ + +/*****************************************/ +/* B 3.2.2 Subprogram Control Statements */ +/*****************************************/ + /* leave for derived classes... */ + +/********************************/ +/* B 3.2.3 Selection Statements */ +/********************************/ + /* leave for derived classes... */ + +/********************************/ +/* B 3.2.4 Iteration Statements */ +/********************************/ + /* leave for derived classes... */ + + + +}; /* generate_c_vardecl_c */ + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/generate_location_list.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/generate_location_list.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,185 @@ +/* + * (c) 2007 Mario de Sousa and Laurent Bessard + * + * 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) + * + */ + +/* + * This is one of the versions available for the 4th stage. + * + * This 4th stage generates a c++ source program equivalent + * to the IL and ST code. + */ + +//#include /* required for NULL */ +//#include +//#include + +//#include "../../util/symtable.hh" + + + + + + + + + +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ +/***********************************************************************/ + +class generate_location_list_c: protected iterator_visitor_c { + + protected: + stage4out_c &s4o; + + private: + symbol_c *current_var_type_symbol; + generate_c_base_c *generate_c_base; + search_base_type_c search_base_type; + + public: + generate_location_list_c(stage4out_c *s4o_ptr): s4o(*s4o_ptr) { + generate_c_base = new generate_c_base_c(s4o_ptr); + current_var_type_symbol = NULL; + } + ~generate_location_list_c(void) { + delete generate_c_base; + } + + bool test_location_type(symbol_c *direct_variable) { + + token_c *location = dynamic_cast(direct_variable); + + if (location == NULL) + /* invalid identifiers... */ + return false; + + switch (location->value[2]) { + case 'X': // bit + if (typeid(*current_var_type_symbol) == typeid(bool_type_name_c)) return true; + break; + case 'B': // Byte, 8 bits + if (typeid(*current_var_type_symbol) == typeid(sint_type_name_c)) return true; + if (typeid(*current_var_type_symbol) == typeid(usint_type_name_c)) return true; + if (typeid(*current_var_type_symbol) == typeid(string_type_name_c)) return true; + if (typeid(*current_var_type_symbol) == typeid(byte_type_name_c)) return true; + break; + case 'W': // Word, 16 bits + if (typeid(*current_var_type_symbol) == typeid(int_type_name_c)) return true; + if (typeid(*current_var_type_symbol) == typeid(uint_type_name_c)) return true; + if (typeid(*current_var_type_symbol) == typeid(word_type_name_c)) return true; + if (typeid(*current_var_type_symbol) == typeid(wstring_type_name_c)) return true; + break; + case 'D': // Double, 32 bits + if (typeid(*current_var_type_symbol) == typeid(dint_type_name_c)) return true; + if (typeid(*current_var_type_symbol) == typeid(udint_type_name_c)) return true; + if (typeid(*current_var_type_symbol) == typeid(real_type_name_c)) return true; + if (typeid(*current_var_type_symbol) == typeid(dword_type_name_c)) return true; + break; + case 'L': // Long, 64 bits + if (typeid(*current_var_type_symbol) == typeid(lint_type_name_c)) return true; + if (typeid(*current_var_type_symbol) == typeid(ulint_type_name_c)) return true; + if (typeid(*current_var_type_symbol) == typeid(lreal_type_name_c)) return true; + if (typeid(*current_var_type_symbol) == typeid(lword_type_name_c)) return true; + break; + default: + if (typeid(*current_var_type_symbol) == typeid(bool_type_name_c)) return true; + } + return false; + } + +/********************************************/ +/* B.1.4.1 Directly Represented Variables */ +/********************************************/ + + void *visit(direct_variable_c *symbol) { + if (current_var_type_symbol) { + s4o.print("__LOCATED_VAR("); + current_var_type_symbol->accept(*generate_c_base); + s4o.print(","); + /* Do not use print_token() as it will change everything into uppercase */ + s4o.printlocation((symbol->value)+1); + s4o.print(","); + s4o.printlocation_comasep((symbol->value)+1); + s4o.print(")\n"); + } + return NULL; + } + + +/********************************************/ +/* B.1.4.3 Declaration and initilization */ +/********************************************/ + +/* [variable_name] location ':' located_var_spec_init */ +/* variable_name -> may be NULL ! */ +//SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused) + void *visit(located_var_decl_c *symbol) { + current_var_type_symbol = spec_init_sperator_c::get_spec(symbol->located_var_spec_init); + if (current_var_type_symbol == NULL) + ERROR; + + current_var_type_symbol = (symbol_c *)(current_var_type_symbol->accept(search_base_type)); + if (current_var_type_symbol == NULL) + ERROR; + + symbol->location->accept(*this); + + current_var_type_symbol = NULL; + return NULL; + } + +/*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */ +/* type_specification ->may be NULL ! */ +//SYM_REF2(global_var_decl_c, global_var_spec, type_specification) + void *visit(global_var_decl_c *symbol) { + current_var_type_symbol = spec_init_sperator_c::get_spec(symbol->type_specification); + if (current_var_type_symbol == NULL) + ERROR; + + current_var_type_symbol = (symbol_c *)(current_var_type_symbol->accept(search_base_type)); + if (current_var_type_symbol == NULL) + ERROR; + + symbol->global_var_spec->accept(*this); + + current_var_type_symbol = NULL; + return NULL; + } + +/* AT direct_variable */ +//SYM_REF2(location_c, direct_variable, unused) + void *visit(location_c *symbol) { + if (test_location_type(symbol->direct_variable)) + symbol->direct_variable->accept(*this); + else + ERROR; + return NULL; + } + +}; /* generate_location_list_c */ diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/get_function_type_decl.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/get_function_type_decl.c Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,1297 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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 lib + * generated code, do not edit by hand + */ +function_type_t get_function_type(identifier_c *function_name) { + +if (!strcasecmp(function_name->value, "BOOL_TO_SINT")) + return function_bool_to_sint; + +if (!strcasecmp(function_name->value, "BOOL_TO_INT")) + return function_bool_to_int; + +if (!strcasecmp(function_name->value, "BOOL_TO_DINT")) + return function_bool_to_dint; + +if (!strcasecmp(function_name->value, "BOOL_TO_LINT")) + return function_bool_to_lint; + +if (!strcasecmp(function_name->value, "BOOL_TO_USINT")) + return function_bool_to_usint; + +if (!strcasecmp(function_name->value, "BOOL_TO_UINT")) + return function_bool_to_uint; + +if (!strcasecmp(function_name->value, "BOOL_TO_UDINT")) + return function_bool_to_udint; + +if (!strcasecmp(function_name->value, "BOOL_TO_ULINT")) + return function_bool_to_ulint; + +if (!strcasecmp(function_name->value, "BOOL_TO_REAL")) + return function_bool_to_real; + +if (!strcasecmp(function_name->value, "BOOL_TO_LREAL")) + return function_bool_to_lreal; + +if (!strcasecmp(function_name->value, "BOOL_TO_TIME")) + return function_bool_to_time; + +if (!strcasecmp(function_name->value, "BOOL_TO_DATE")) + return function_bool_to_date; + +if (!strcasecmp(function_name->value, "BOOL_TO_TOD")) + return function_bool_to_tod; + +if (!strcasecmp(function_name->value, "BOOL_TO_DT")) + return function_bool_to_dt; + +if (!strcasecmp(function_name->value, "BOOL_TO_STRING")) + return function_bool_to_string; + +if (!strcasecmp(function_name->value, "BOOL_TO_BYTE")) + return function_bool_to_byte; + +if (!strcasecmp(function_name->value, "BOOL_TO_WORD")) + return function_bool_to_word; + +if (!strcasecmp(function_name->value, "BOOL_TO_DWORD")) + return function_bool_to_dword; + +if (!strcasecmp(function_name->value, "BOOL_TO_LWORD")) + return function_bool_to_lword; + +if (!strcasecmp(function_name->value, "SINT_TO_BOOL")) + return function_sint_to_bool; + +if (!strcasecmp(function_name->value, "SINT_TO_INT")) + return function_sint_to_int; + +if (!strcasecmp(function_name->value, "SINT_TO_DINT")) + return function_sint_to_dint; + +if (!strcasecmp(function_name->value, "SINT_TO_LINT")) + return function_sint_to_lint; + +if (!strcasecmp(function_name->value, "SINT_TO_USINT")) + return function_sint_to_usint; + +if (!strcasecmp(function_name->value, "SINT_TO_UINT")) + return function_sint_to_uint; + +if (!strcasecmp(function_name->value, "SINT_TO_UDINT")) + return function_sint_to_udint; + +if (!strcasecmp(function_name->value, "SINT_TO_ULINT")) + return function_sint_to_ulint; + +if (!strcasecmp(function_name->value, "SINT_TO_REAL")) + return function_sint_to_real; + +if (!strcasecmp(function_name->value, "SINT_TO_LREAL")) + return function_sint_to_lreal; + +if (!strcasecmp(function_name->value, "SINT_TO_TIME")) + return function_sint_to_time; + +if (!strcasecmp(function_name->value, "SINT_TO_DATE")) + return function_sint_to_date; + +if (!strcasecmp(function_name->value, "SINT_TO_TOD")) + return function_sint_to_tod; + +if (!strcasecmp(function_name->value, "SINT_TO_DT")) + return function_sint_to_dt; + +if (!strcasecmp(function_name->value, "SINT_TO_STRING")) + return function_sint_to_string; + +if (!strcasecmp(function_name->value, "SINT_TO_BYTE")) + return function_sint_to_byte; + +if (!strcasecmp(function_name->value, "SINT_TO_WORD")) + return function_sint_to_word; + +if (!strcasecmp(function_name->value, "SINT_TO_DWORD")) + return function_sint_to_dword; + +if (!strcasecmp(function_name->value, "SINT_TO_LWORD")) + return function_sint_to_lword; + +if (!strcasecmp(function_name->value, "INT_TO_BOOL")) + return function_int_to_bool; + +if (!strcasecmp(function_name->value, "INT_TO_SINT")) + return function_int_to_sint; + +if (!strcasecmp(function_name->value, "INT_TO_DINT")) + return function_int_to_dint; + +if (!strcasecmp(function_name->value, "INT_TO_LINT")) + return function_int_to_lint; + +if (!strcasecmp(function_name->value, "INT_TO_USINT")) + return function_int_to_usint; + +if (!strcasecmp(function_name->value, "INT_TO_UINT")) + return function_int_to_uint; + +if (!strcasecmp(function_name->value, "INT_TO_UDINT")) + return function_int_to_udint; + +if (!strcasecmp(function_name->value, "INT_TO_ULINT")) + return function_int_to_ulint; + +if (!strcasecmp(function_name->value, "INT_TO_REAL")) + return function_int_to_real; + +if (!strcasecmp(function_name->value, "INT_TO_LREAL")) + return function_int_to_lreal; + +if (!strcasecmp(function_name->value, "INT_TO_TIME")) + return function_int_to_time; + +if (!strcasecmp(function_name->value, "INT_TO_DATE")) + return function_int_to_date; + +if (!strcasecmp(function_name->value, "INT_TO_TOD")) + return function_int_to_tod; + +if (!strcasecmp(function_name->value, "INT_TO_DT")) + return function_int_to_dt; + +if (!strcasecmp(function_name->value, "INT_TO_STRING")) + return function_int_to_string; + +if (!strcasecmp(function_name->value, "INT_TO_BYTE")) + return function_int_to_byte; + +if (!strcasecmp(function_name->value, "INT_TO_WORD")) + return function_int_to_word; + +if (!strcasecmp(function_name->value, "INT_TO_DWORD")) + return function_int_to_dword; + +if (!strcasecmp(function_name->value, "INT_TO_LWORD")) + return function_int_to_lword; + +if (!strcasecmp(function_name->value, "DINT_TO_BOOL")) + return function_dint_to_bool; + +if (!strcasecmp(function_name->value, "DINT_TO_SINT")) + return function_dint_to_sint; + +if (!strcasecmp(function_name->value, "DINT_TO_INT")) + return function_dint_to_int; + +if (!strcasecmp(function_name->value, "DINT_TO_LINT")) + return function_dint_to_lint; + +if (!strcasecmp(function_name->value, "DINT_TO_USINT")) + return function_dint_to_usint; + +if (!strcasecmp(function_name->value, "DINT_TO_UINT")) + return function_dint_to_uint; + +if (!strcasecmp(function_name->value, "DINT_TO_UDINT")) + return function_dint_to_udint; + +if (!strcasecmp(function_name->value, "DINT_TO_ULINT")) + return function_dint_to_ulint; + +if (!strcasecmp(function_name->value, "DINT_TO_REAL")) + return function_dint_to_real; + +if (!strcasecmp(function_name->value, "DINT_TO_LREAL")) + return function_dint_to_lreal; + +if (!strcasecmp(function_name->value, "DINT_TO_TIME")) + return function_dint_to_time; + +if (!strcasecmp(function_name->value, "DINT_TO_DATE")) + return function_dint_to_date; + +if (!strcasecmp(function_name->value, "DINT_TO_TOD")) + return function_dint_to_tod; + +if (!strcasecmp(function_name->value, "DINT_TO_DT")) + return function_dint_to_dt; + +if (!strcasecmp(function_name->value, "DINT_TO_STRING")) + return function_dint_to_string; + +if (!strcasecmp(function_name->value, "DINT_TO_BYTE")) + return function_dint_to_byte; + +if (!strcasecmp(function_name->value, "DINT_TO_WORD")) + return function_dint_to_word; + +if (!strcasecmp(function_name->value, "DINT_TO_DWORD")) + return function_dint_to_dword; + +if (!strcasecmp(function_name->value, "DINT_TO_LWORD")) + return function_dint_to_lword; + +if (!strcasecmp(function_name->value, "LINT_TO_BOOL")) + return function_lint_to_bool; + +if (!strcasecmp(function_name->value, "LINT_TO_SINT")) + return function_lint_to_sint; + +if (!strcasecmp(function_name->value, "LINT_TO_INT")) + return function_lint_to_int; + +if (!strcasecmp(function_name->value, "LINT_TO_DINT")) + return function_lint_to_dint; + +if (!strcasecmp(function_name->value, "LINT_TO_USINT")) + return function_lint_to_usint; + +if (!strcasecmp(function_name->value, "LINT_TO_UINT")) + return function_lint_to_uint; + +if (!strcasecmp(function_name->value, "LINT_TO_UDINT")) + return function_lint_to_udint; + +if (!strcasecmp(function_name->value, "LINT_TO_ULINT")) + return function_lint_to_ulint; + +if (!strcasecmp(function_name->value, "LINT_TO_REAL")) + return function_lint_to_real; + +if (!strcasecmp(function_name->value, "LINT_TO_LREAL")) + return function_lint_to_lreal; + +if (!strcasecmp(function_name->value, "LINT_TO_TIME")) + return function_lint_to_time; + +if (!strcasecmp(function_name->value, "LINT_TO_DATE")) + return function_lint_to_date; + +if (!strcasecmp(function_name->value, "LINT_TO_TOD")) + return function_lint_to_tod; + +if (!strcasecmp(function_name->value, "LINT_TO_DT")) + return function_lint_to_dt; + +if (!strcasecmp(function_name->value, "LINT_TO_STRING")) + return function_lint_to_string; + +if (!strcasecmp(function_name->value, "LINT_TO_BYTE")) + return function_lint_to_byte; + +if (!strcasecmp(function_name->value, "LINT_TO_WORD")) + return function_lint_to_word; + +if (!strcasecmp(function_name->value, "LINT_TO_DWORD")) + return function_lint_to_dword; + +if (!strcasecmp(function_name->value, "LINT_TO_LWORD")) + return function_lint_to_lword; + +if (!strcasecmp(function_name->value, "USINT_TO_BOOL")) + return function_usint_to_bool; + +if (!strcasecmp(function_name->value, "USINT_TO_SINT")) + return function_usint_to_sint; + +if (!strcasecmp(function_name->value, "USINT_TO_INT")) + return function_usint_to_int; + +if (!strcasecmp(function_name->value, "USINT_TO_DINT")) + return function_usint_to_dint; + +if (!strcasecmp(function_name->value, "USINT_TO_LINT")) + return function_usint_to_lint; + +if (!strcasecmp(function_name->value, "USINT_TO_UINT")) + return function_usint_to_uint; + +if (!strcasecmp(function_name->value, "USINT_TO_UDINT")) + return function_usint_to_udint; + +if (!strcasecmp(function_name->value, "USINT_TO_ULINT")) + return function_usint_to_ulint; + +if (!strcasecmp(function_name->value, "USINT_TO_REAL")) + return function_usint_to_real; + +if (!strcasecmp(function_name->value, "USINT_TO_LREAL")) + return function_usint_to_lreal; + +if (!strcasecmp(function_name->value, "USINT_TO_TIME")) + return function_usint_to_time; + +if (!strcasecmp(function_name->value, "USINT_TO_DATE")) + return function_usint_to_date; + +if (!strcasecmp(function_name->value, "USINT_TO_TOD")) + return function_usint_to_tod; + +if (!strcasecmp(function_name->value, "USINT_TO_DT")) + return function_usint_to_dt; + +if (!strcasecmp(function_name->value, "USINT_TO_STRING")) + return function_usint_to_string; + +if (!strcasecmp(function_name->value, "USINT_TO_BYTE")) + return function_usint_to_byte; + +if (!strcasecmp(function_name->value, "USINT_TO_WORD")) + return function_usint_to_word; + +if (!strcasecmp(function_name->value, "USINT_TO_DWORD")) + return function_usint_to_dword; + +if (!strcasecmp(function_name->value, "USINT_TO_LWORD")) + return function_usint_to_lword; + +if (!strcasecmp(function_name->value, "UINT_TO_BOOL")) + return function_uint_to_bool; + +if (!strcasecmp(function_name->value, "UINT_TO_SINT")) + return function_uint_to_sint; + +if (!strcasecmp(function_name->value, "UINT_TO_INT")) + return function_uint_to_int; + +if (!strcasecmp(function_name->value, "UINT_TO_DINT")) + return function_uint_to_dint; + +if (!strcasecmp(function_name->value, "UINT_TO_LINT")) + return function_uint_to_lint; + +if (!strcasecmp(function_name->value, "UINT_TO_USINT")) + return function_uint_to_usint; + +if (!strcasecmp(function_name->value, "UINT_TO_UDINT")) + return function_uint_to_udint; + +if (!strcasecmp(function_name->value, "UINT_TO_ULINT")) + return function_uint_to_ulint; + +if (!strcasecmp(function_name->value, "UINT_TO_REAL")) + return function_uint_to_real; + +if (!strcasecmp(function_name->value, "UINT_TO_LREAL")) + return function_uint_to_lreal; + +if (!strcasecmp(function_name->value, "UINT_TO_TIME")) + return function_uint_to_time; + +if (!strcasecmp(function_name->value, "UINT_TO_DATE")) + return function_uint_to_date; + +if (!strcasecmp(function_name->value, "UINT_TO_TOD")) + return function_uint_to_tod; + +if (!strcasecmp(function_name->value, "UINT_TO_DT")) + return function_uint_to_dt; + +if (!strcasecmp(function_name->value, "UINT_TO_STRING")) + return function_uint_to_string; + +if (!strcasecmp(function_name->value, "UINT_TO_BYTE")) + return function_uint_to_byte; + +if (!strcasecmp(function_name->value, "UINT_TO_WORD")) + return function_uint_to_word; + +if (!strcasecmp(function_name->value, "UINT_TO_DWORD")) + return function_uint_to_dword; + +if (!strcasecmp(function_name->value, "UINT_TO_LWORD")) + return function_uint_to_lword; + +if (!strcasecmp(function_name->value, "UDINT_TO_BOOL")) + return function_udint_to_bool; + +if (!strcasecmp(function_name->value, "UDINT_TO_SINT")) + return function_udint_to_sint; + +if (!strcasecmp(function_name->value, "UDINT_TO_INT")) + return function_udint_to_int; + +if (!strcasecmp(function_name->value, "UDINT_TO_DINT")) + return function_udint_to_dint; + +if (!strcasecmp(function_name->value, "UDINT_TO_LINT")) + return function_udint_to_lint; + +if (!strcasecmp(function_name->value, "UDINT_TO_USINT")) + return function_udint_to_usint; + +if (!strcasecmp(function_name->value, "UDINT_TO_UINT")) + return function_udint_to_uint; + +if (!strcasecmp(function_name->value, "UDINT_TO_ULINT")) + return function_udint_to_ulint; + +if (!strcasecmp(function_name->value, "UDINT_TO_REAL")) + return function_udint_to_real; + +if (!strcasecmp(function_name->value, "UDINT_TO_LREAL")) + return function_udint_to_lreal; + +if (!strcasecmp(function_name->value, "UDINT_TO_TIME")) + return function_udint_to_time; + +if (!strcasecmp(function_name->value, "UDINT_TO_DATE")) + return function_udint_to_date; + +if (!strcasecmp(function_name->value, "UDINT_TO_TOD")) + return function_udint_to_tod; + +if (!strcasecmp(function_name->value, "UDINT_TO_DT")) + return function_udint_to_dt; + +if (!strcasecmp(function_name->value, "UDINT_TO_STRING")) + return function_udint_to_string; + +if (!strcasecmp(function_name->value, "UDINT_TO_BYTE")) + return function_udint_to_byte; + +if (!strcasecmp(function_name->value, "UDINT_TO_WORD")) + return function_udint_to_word; + +if (!strcasecmp(function_name->value, "UDINT_TO_DWORD")) + return function_udint_to_dword; + +if (!strcasecmp(function_name->value, "UDINT_TO_LWORD")) + return function_udint_to_lword; + +if (!strcasecmp(function_name->value, "ULINT_TO_BOOL")) + return function_ulint_to_bool; + +if (!strcasecmp(function_name->value, "ULINT_TO_SINT")) + return function_ulint_to_sint; + +if (!strcasecmp(function_name->value, "ULINT_TO_INT")) + return function_ulint_to_int; + +if (!strcasecmp(function_name->value, "ULINT_TO_DINT")) + return function_ulint_to_dint; + +if (!strcasecmp(function_name->value, "ULINT_TO_LINT")) + return function_ulint_to_lint; + +if (!strcasecmp(function_name->value, "ULINT_TO_USINT")) + return function_ulint_to_usint; + +if (!strcasecmp(function_name->value, "ULINT_TO_UINT")) + return function_ulint_to_uint; + +if (!strcasecmp(function_name->value, "ULINT_TO_UDINT")) + return function_ulint_to_udint; + +if (!strcasecmp(function_name->value, "ULINT_TO_REAL")) + return function_ulint_to_real; + +if (!strcasecmp(function_name->value, "ULINT_TO_LREAL")) + return function_ulint_to_lreal; + +if (!strcasecmp(function_name->value, "ULINT_TO_TIME")) + return function_ulint_to_time; + +if (!strcasecmp(function_name->value, "ULINT_TO_DATE")) + return function_ulint_to_date; + +if (!strcasecmp(function_name->value, "ULINT_TO_TOD")) + return function_ulint_to_tod; + +if (!strcasecmp(function_name->value, "ULINT_TO_DT")) + return function_ulint_to_dt; + +if (!strcasecmp(function_name->value, "ULINT_TO_STRING")) + return function_ulint_to_string; + +if (!strcasecmp(function_name->value, "ULINT_TO_BYTE")) + return function_ulint_to_byte; + +if (!strcasecmp(function_name->value, "ULINT_TO_WORD")) + return function_ulint_to_word; + +if (!strcasecmp(function_name->value, "ULINT_TO_DWORD")) + return function_ulint_to_dword; + +if (!strcasecmp(function_name->value, "ULINT_TO_LWORD")) + return function_ulint_to_lword; + +if (!strcasecmp(function_name->value, "REAL_TO_BOOL")) + return function_real_to_bool; + +if (!strcasecmp(function_name->value, "REAL_TO_SINT")) + return function_real_to_sint; + +if (!strcasecmp(function_name->value, "REAL_TO_INT")) + return function_real_to_int; + +if (!strcasecmp(function_name->value, "REAL_TO_DINT")) + return function_real_to_dint; + +if (!strcasecmp(function_name->value, "REAL_TO_LINT")) + return function_real_to_lint; + +if (!strcasecmp(function_name->value, "REAL_TO_USINT")) + return function_real_to_usint; + +if (!strcasecmp(function_name->value, "REAL_TO_UINT")) + return function_real_to_uint; + +if (!strcasecmp(function_name->value, "REAL_TO_UDINT")) + return function_real_to_udint; + +if (!strcasecmp(function_name->value, "REAL_TO_ULINT")) + return function_real_to_ulint; + +if (!strcasecmp(function_name->value, "REAL_TO_LREAL")) + return function_real_to_lreal; + +if (!strcasecmp(function_name->value, "REAL_TO_TIME")) + return function_real_to_time; + +if (!strcasecmp(function_name->value, "REAL_TO_DATE")) + return function_real_to_date; + +if (!strcasecmp(function_name->value, "REAL_TO_TOD")) + return function_real_to_tod; + +if (!strcasecmp(function_name->value, "REAL_TO_DT")) + return function_real_to_dt; + +if (!strcasecmp(function_name->value, "REAL_TO_STRING")) + return function_real_to_string; + +if (!strcasecmp(function_name->value, "REAL_TO_BYTE")) + return function_real_to_byte; + +if (!strcasecmp(function_name->value, "REAL_TO_WORD")) + return function_real_to_word; + +if (!strcasecmp(function_name->value, "REAL_TO_DWORD")) + return function_real_to_dword; + +if (!strcasecmp(function_name->value, "REAL_TO_LWORD")) + return function_real_to_lword; + +if (!strcasecmp(function_name->value, "LREAL_TO_BOOL")) + return function_lreal_to_bool; + +if (!strcasecmp(function_name->value, "LREAL_TO_SINT")) + return function_lreal_to_sint; + +if (!strcasecmp(function_name->value, "LREAL_TO_INT")) + return function_lreal_to_int; + +if (!strcasecmp(function_name->value, "LREAL_TO_DINT")) + return function_lreal_to_dint; + +if (!strcasecmp(function_name->value, "LREAL_TO_LINT")) + return function_lreal_to_lint; + +if (!strcasecmp(function_name->value, "LREAL_TO_USINT")) + return function_lreal_to_usint; + +if (!strcasecmp(function_name->value, "LREAL_TO_UINT")) + return function_lreal_to_uint; + +if (!strcasecmp(function_name->value, "LREAL_TO_UDINT")) + return function_lreal_to_udint; + +if (!strcasecmp(function_name->value, "LREAL_TO_ULINT")) + return function_lreal_to_ulint; + +if (!strcasecmp(function_name->value, "LREAL_TO_REAL")) + return function_lreal_to_real; + +if (!strcasecmp(function_name->value, "LREAL_TO_TIME")) + return function_lreal_to_time; + +if (!strcasecmp(function_name->value, "LREAL_TO_DATE")) + return function_lreal_to_date; + +if (!strcasecmp(function_name->value, "LREAL_TO_TOD")) + return function_lreal_to_tod; + +if (!strcasecmp(function_name->value, "LREAL_TO_DT")) + return function_lreal_to_dt; + +if (!strcasecmp(function_name->value, "LREAL_TO_STRING")) + return function_lreal_to_string; + +if (!strcasecmp(function_name->value, "LREAL_TO_BYTE")) + return function_lreal_to_byte; + +if (!strcasecmp(function_name->value, "LREAL_TO_WORD")) + return function_lreal_to_word; + +if (!strcasecmp(function_name->value, "LREAL_TO_DWORD")) + return function_lreal_to_dword; + +if (!strcasecmp(function_name->value, "LREAL_TO_LWORD")) + return function_lreal_to_lword; + +if (!strcasecmp(function_name->value, "TIME_TO_SINT")) + return function_time_to_sint; + +if (!strcasecmp(function_name->value, "TIME_TO_INT")) + return function_time_to_int; + +if (!strcasecmp(function_name->value, "TIME_TO_DINT")) + return function_time_to_dint; + +if (!strcasecmp(function_name->value, "TIME_TO_LINT")) + return function_time_to_lint; + +if (!strcasecmp(function_name->value, "TIME_TO_USINT")) + return function_time_to_usint; + +if (!strcasecmp(function_name->value, "TIME_TO_UINT")) + return function_time_to_uint; + +if (!strcasecmp(function_name->value, "TIME_TO_UDINT")) + return function_time_to_udint; + +if (!strcasecmp(function_name->value, "TIME_TO_ULINT")) + return function_time_to_ulint; + +if (!strcasecmp(function_name->value, "TIME_TO_REAL")) + return function_time_to_real; + +if (!strcasecmp(function_name->value, "TIME_TO_LREAL")) + return function_time_to_lreal; + +if (!strcasecmp(function_name->value, "TIME_TO_STRING")) + return function_time_to_string; + +if (!strcasecmp(function_name->value, "TIME_TO_BYTE")) + return function_time_to_byte; + +if (!strcasecmp(function_name->value, "TIME_TO_WORD")) + return function_time_to_word; + +if (!strcasecmp(function_name->value, "TIME_TO_DWORD")) + return function_time_to_dword; + +if (!strcasecmp(function_name->value, "TIME_TO_LWORD")) + return function_time_to_lword; + +if (!strcasecmp(function_name->value, "DATE_TO_SINT")) + return function_date_to_sint; + +if (!strcasecmp(function_name->value, "DATE_TO_INT")) + return function_date_to_int; + +if (!strcasecmp(function_name->value, "DATE_TO_DINT")) + return function_date_to_dint; + +if (!strcasecmp(function_name->value, "DATE_TO_LINT")) + return function_date_to_lint; + +if (!strcasecmp(function_name->value, "DATE_TO_USINT")) + return function_date_to_usint; + +if (!strcasecmp(function_name->value, "DATE_TO_UINT")) + return function_date_to_uint; + +if (!strcasecmp(function_name->value, "DATE_TO_UDINT")) + return function_date_to_udint; + +if (!strcasecmp(function_name->value, "DATE_TO_ULINT")) + return function_date_to_ulint; + +if (!strcasecmp(function_name->value, "DATE_TO_REAL")) + return function_date_to_real; + +if (!strcasecmp(function_name->value, "DATE_TO_LREAL")) + return function_date_to_lreal; + +if (!strcasecmp(function_name->value, "DATE_TO_STRING")) + return function_date_to_string; + +if (!strcasecmp(function_name->value, "DATE_TO_BYTE")) + return function_date_to_byte; + +if (!strcasecmp(function_name->value, "DATE_TO_WORD")) + return function_date_to_word; + +if (!strcasecmp(function_name->value, "DATE_TO_DWORD")) + return function_date_to_dword; + +if (!strcasecmp(function_name->value, "DATE_TO_LWORD")) + return function_date_to_lword; + +if (!strcasecmp(function_name->value, "TOD_TO_SINT")) + return function_tod_to_sint; + +if (!strcasecmp(function_name->value, "TOD_TO_INT")) + return function_tod_to_int; + +if (!strcasecmp(function_name->value, "TOD_TO_DINT")) + return function_tod_to_dint; + +if (!strcasecmp(function_name->value, "TOD_TO_LINT")) + return function_tod_to_lint; + +if (!strcasecmp(function_name->value, "TOD_TO_USINT")) + return function_tod_to_usint; + +if (!strcasecmp(function_name->value, "TOD_TO_UINT")) + return function_tod_to_uint; + +if (!strcasecmp(function_name->value, "TOD_TO_UDINT")) + return function_tod_to_udint; + +if (!strcasecmp(function_name->value, "TOD_TO_ULINT")) + return function_tod_to_ulint; + +if (!strcasecmp(function_name->value, "TOD_TO_REAL")) + return function_tod_to_real; + +if (!strcasecmp(function_name->value, "TOD_TO_LREAL")) + return function_tod_to_lreal; + +if (!strcasecmp(function_name->value, "TOD_TO_STRING")) + return function_tod_to_string; + +if (!strcasecmp(function_name->value, "TOD_TO_BYTE")) + return function_tod_to_byte; + +if (!strcasecmp(function_name->value, "TOD_TO_WORD")) + return function_tod_to_word; + +if (!strcasecmp(function_name->value, "TOD_TO_DWORD")) + return function_tod_to_dword; + +if (!strcasecmp(function_name->value, "TOD_TO_LWORD")) + return function_tod_to_lword; + +if (!strcasecmp(function_name->value, "DT_TO_SINT")) + return function_dt_to_sint; + +if (!strcasecmp(function_name->value, "DT_TO_INT")) + return function_dt_to_int; + +if (!strcasecmp(function_name->value, "DT_TO_DINT")) + return function_dt_to_dint; + +if (!strcasecmp(function_name->value, "DT_TO_LINT")) + return function_dt_to_lint; + +if (!strcasecmp(function_name->value, "DT_TO_USINT")) + return function_dt_to_usint; + +if (!strcasecmp(function_name->value, "DT_TO_UINT")) + return function_dt_to_uint; + +if (!strcasecmp(function_name->value, "DT_TO_UDINT")) + return function_dt_to_udint; + +if (!strcasecmp(function_name->value, "DT_TO_ULINT")) + return function_dt_to_ulint; + +if (!strcasecmp(function_name->value, "DT_TO_REAL")) + return function_dt_to_real; + +if (!strcasecmp(function_name->value, "DT_TO_LREAL")) + return function_dt_to_lreal; + +if (!strcasecmp(function_name->value, "DT_TO_STRING")) + return function_dt_to_string; + +if (!strcasecmp(function_name->value, "DT_TO_BYTE")) + return function_dt_to_byte; + +if (!strcasecmp(function_name->value, "DT_TO_WORD")) + return function_dt_to_word; + +if (!strcasecmp(function_name->value, "DT_TO_DWORD")) + return function_dt_to_dword; + +if (!strcasecmp(function_name->value, "DT_TO_LWORD")) + return function_dt_to_lword; + +if (!strcasecmp(function_name->value, "STRING_TO_BOOL")) + return function_string_to_bool; + +if (!strcasecmp(function_name->value, "STRING_TO_SINT")) + return function_string_to_sint; + +if (!strcasecmp(function_name->value, "STRING_TO_INT")) + return function_string_to_int; + +if (!strcasecmp(function_name->value, "STRING_TO_DINT")) + return function_string_to_dint; + +if (!strcasecmp(function_name->value, "STRING_TO_LINT")) + return function_string_to_lint; + +if (!strcasecmp(function_name->value, "STRING_TO_USINT")) + return function_string_to_usint; + +if (!strcasecmp(function_name->value, "STRING_TO_UINT")) + return function_string_to_uint; + +if (!strcasecmp(function_name->value, "STRING_TO_UDINT")) + return function_string_to_udint; + +if (!strcasecmp(function_name->value, "STRING_TO_ULINT")) + return function_string_to_ulint; + +if (!strcasecmp(function_name->value, "STRING_TO_REAL")) + return function_string_to_real; + +if (!strcasecmp(function_name->value, "STRING_TO_LREAL")) + return function_string_to_lreal; + +if (!strcasecmp(function_name->value, "STRING_TO_TIME")) + return function_string_to_time; + +if (!strcasecmp(function_name->value, "STRING_TO_DATE")) + return function_string_to_date; + +if (!strcasecmp(function_name->value, "STRING_TO_TOD")) + return function_string_to_tod; + +if (!strcasecmp(function_name->value, "STRING_TO_DT")) + return function_string_to_dt; + +if (!strcasecmp(function_name->value, "STRING_TO_BYTE")) + return function_string_to_byte; + +if (!strcasecmp(function_name->value, "STRING_TO_WORD")) + return function_string_to_word; + +if (!strcasecmp(function_name->value, "STRING_TO_DWORD")) + return function_string_to_dword; + +if (!strcasecmp(function_name->value, "STRING_TO_LWORD")) + return function_string_to_lword; + +if (!strcasecmp(function_name->value, "BYTE_TO_BOOL")) + return function_byte_to_bool; + +if (!strcasecmp(function_name->value, "BYTE_TO_SINT")) + return function_byte_to_sint; + +if (!strcasecmp(function_name->value, "BYTE_TO_INT")) + return function_byte_to_int; + +if (!strcasecmp(function_name->value, "BYTE_TO_DINT")) + return function_byte_to_dint; + +if (!strcasecmp(function_name->value, "BYTE_TO_LINT")) + return function_byte_to_lint; + +if (!strcasecmp(function_name->value, "BYTE_TO_USINT")) + return function_byte_to_usint; + +if (!strcasecmp(function_name->value, "BYTE_TO_UINT")) + return function_byte_to_uint; + +if (!strcasecmp(function_name->value, "BYTE_TO_UDINT")) + return function_byte_to_udint; + +if (!strcasecmp(function_name->value, "BYTE_TO_ULINT")) + return function_byte_to_ulint; + +if (!strcasecmp(function_name->value, "BYTE_TO_REAL")) + return function_byte_to_real; + +if (!strcasecmp(function_name->value, "BYTE_TO_LREAL")) + return function_byte_to_lreal; + +if (!strcasecmp(function_name->value, "BYTE_TO_TIME")) + return function_byte_to_time; + +if (!strcasecmp(function_name->value, "BYTE_TO_DATE")) + return function_byte_to_date; + +if (!strcasecmp(function_name->value, "BYTE_TO_TOD")) + return function_byte_to_tod; + +if (!strcasecmp(function_name->value, "BYTE_TO_DT")) + return function_byte_to_dt; + +if (!strcasecmp(function_name->value, "BYTE_TO_STRING")) + return function_byte_to_string; + +if (!strcasecmp(function_name->value, "BYTE_TO_WORD")) + return function_byte_to_word; + +if (!strcasecmp(function_name->value, "BYTE_TO_DWORD")) + return function_byte_to_dword; + +if (!strcasecmp(function_name->value, "BYTE_TO_LWORD")) + return function_byte_to_lword; + +if (!strcasecmp(function_name->value, "WORD_TO_BOOL")) + return function_word_to_bool; + +if (!strcasecmp(function_name->value, "WORD_TO_SINT")) + return function_word_to_sint; + +if (!strcasecmp(function_name->value, "WORD_TO_INT")) + return function_word_to_int; + +if (!strcasecmp(function_name->value, "WORD_TO_DINT")) + return function_word_to_dint; + +if (!strcasecmp(function_name->value, "WORD_TO_LINT")) + return function_word_to_lint; + +if (!strcasecmp(function_name->value, "WORD_TO_USINT")) + return function_word_to_usint; + +if (!strcasecmp(function_name->value, "WORD_TO_UINT")) + return function_word_to_uint; + +if (!strcasecmp(function_name->value, "WORD_TO_UDINT")) + return function_word_to_udint; + +if (!strcasecmp(function_name->value, "WORD_TO_ULINT")) + return function_word_to_ulint; + +if (!strcasecmp(function_name->value, "WORD_TO_REAL")) + return function_word_to_real; + +if (!strcasecmp(function_name->value, "WORD_TO_LREAL")) + return function_word_to_lreal; + +if (!strcasecmp(function_name->value, "WORD_TO_TIME")) + return function_word_to_time; + +if (!strcasecmp(function_name->value, "WORD_TO_DATE")) + return function_word_to_date; + +if (!strcasecmp(function_name->value, "WORD_TO_TOD")) + return function_word_to_tod; + +if (!strcasecmp(function_name->value, "WORD_TO_DT")) + return function_word_to_dt; + +if (!strcasecmp(function_name->value, "WORD_TO_STRING")) + return function_word_to_string; + +if (!strcasecmp(function_name->value, "WORD_TO_BYTE")) + return function_word_to_byte; + +if (!strcasecmp(function_name->value, "WORD_TO_DWORD")) + return function_word_to_dword; + +if (!strcasecmp(function_name->value, "WORD_TO_LWORD")) + return function_word_to_lword; + +if (!strcasecmp(function_name->value, "DWORD_TO_BOOL")) + return function_dword_to_bool; + +if (!strcasecmp(function_name->value, "DWORD_TO_SINT")) + return function_dword_to_sint; + +if (!strcasecmp(function_name->value, "DWORD_TO_INT")) + return function_dword_to_int; + +if (!strcasecmp(function_name->value, "DWORD_TO_DINT")) + return function_dword_to_dint; + +if (!strcasecmp(function_name->value, "DWORD_TO_LINT")) + return function_dword_to_lint; + +if (!strcasecmp(function_name->value, "DWORD_TO_USINT")) + return function_dword_to_usint; + +if (!strcasecmp(function_name->value, "DWORD_TO_UINT")) + return function_dword_to_uint; + +if (!strcasecmp(function_name->value, "DWORD_TO_UDINT")) + return function_dword_to_udint; + +if (!strcasecmp(function_name->value, "DWORD_TO_ULINT")) + return function_dword_to_ulint; + +if (!strcasecmp(function_name->value, "DWORD_TO_REAL")) + return function_dword_to_real; + +if (!strcasecmp(function_name->value, "DWORD_TO_LREAL")) + return function_dword_to_lreal; + +if (!strcasecmp(function_name->value, "DWORD_TO_TIME")) + return function_dword_to_time; + +if (!strcasecmp(function_name->value, "DWORD_TO_DATE")) + return function_dword_to_date; + +if (!strcasecmp(function_name->value, "DWORD_TO_TOD")) + return function_dword_to_tod; + +if (!strcasecmp(function_name->value, "DWORD_TO_DT")) + return function_dword_to_dt; + +if (!strcasecmp(function_name->value, "DWORD_TO_STRING")) + return function_dword_to_string; + +if (!strcasecmp(function_name->value, "DWORD_TO_BYTE")) + return function_dword_to_byte; + +if (!strcasecmp(function_name->value, "DWORD_TO_WORD")) + return function_dword_to_word; + +if (!strcasecmp(function_name->value, "DWORD_TO_LWORD")) + return function_dword_to_lword; + +if (!strcasecmp(function_name->value, "LWORD_TO_BOOL")) + return function_lword_to_bool; + +if (!strcasecmp(function_name->value, "LWORD_TO_SINT")) + return function_lword_to_sint; + +if (!strcasecmp(function_name->value, "LWORD_TO_INT")) + return function_lword_to_int; + +if (!strcasecmp(function_name->value, "LWORD_TO_DINT")) + return function_lword_to_dint; + +if (!strcasecmp(function_name->value, "LWORD_TO_LINT")) + return function_lword_to_lint; + +if (!strcasecmp(function_name->value, "LWORD_TO_USINT")) + return function_lword_to_usint; + +if (!strcasecmp(function_name->value, "LWORD_TO_UINT")) + return function_lword_to_uint; + +if (!strcasecmp(function_name->value, "LWORD_TO_UDINT")) + return function_lword_to_udint; + +if (!strcasecmp(function_name->value, "LWORD_TO_ULINT")) + return function_lword_to_ulint; + +if (!strcasecmp(function_name->value, "LWORD_TO_REAL")) + return function_lword_to_real; + +if (!strcasecmp(function_name->value, "LWORD_TO_LREAL")) + return function_lword_to_lreal; + +if (!strcasecmp(function_name->value, "LWORD_TO_TIME")) + return function_lword_to_time; + +if (!strcasecmp(function_name->value, "LWORD_TO_DATE")) + return function_lword_to_date; + +if (!strcasecmp(function_name->value, "LWORD_TO_TOD")) + return function_lword_to_tod; + +if (!strcasecmp(function_name->value, "LWORD_TO_DT")) + return function_lword_to_dt; + +if (!strcasecmp(function_name->value, "LWORD_TO_STRING")) + return function_lword_to_string; + +if (!strcasecmp(function_name->value, "LWORD_TO_BYTE")) + return function_lword_to_byte; + +if (!strcasecmp(function_name->value, "LWORD_TO_WORD")) + return function_lword_to_word; + +if (!strcasecmp(function_name->value, "LWORD_TO_DWORD")) + return function_lword_to_dword; + +if (!strcasecmp(function_name->value, "TRUNC")) + return function_trunc; + +if (!strcasecmp(function_name->value, "BCD_TO_USINT")) + return function_bcd_to_usint; + +if (!strcasecmp(function_name->value, "BCD_TO_UINT")) + return function_bcd_to_uint; + +if (!strcasecmp(function_name->value, "BCD_TO_UDINT")) + return function_bcd_to_udint; + +if (!strcasecmp(function_name->value, "BCD_TO_ULINT")) + return function_bcd_to_ulint; + +if (!strcasecmp(function_name->value, "USINT_TO_BCD")) + return function_usint_to_bcd; + +if (!strcasecmp(function_name->value, "UINT_TO_BCD")) + return function_uint_to_bcd; + +if (!strcasecmp(function_name->value, "UDINT_TO_BCD")) + return function_udint_to_bcd; + +if (!strcasecmp(function_name->value, "ULINT_TO_BCD")) + return function_ulint_to_bcd; + +if (!strcasecmp(function_name->value, "DATE_AND_TIME_TO_TIME_OF_DAY")) + return function_date_and_time_to_time_of_day; + +if (!strcasecmp(function_name->value, "DATE_AND_TIME_TO_DATE")) + return function_date_and_time_to_date; + +if (!strcasecmp(function_name->value, "ABS")) + return function_abs; + +if (!strcasecmp(function_name->value, "SQRT")) + return function_sqrt; + +if (!strcasecmp(function_name->value, "LN")) + return function_ln; + +if (!strcasecmp(function_name->value, "LOG")) + return function_log; + +if (!strcasecmp(function_name->value, "EXP")) + return function_exp; + +if (!strcasecmp(function_name->value, "SIN")) + return function_sin; + +if (!strcasecmp(function_name->value, "COS")) + return function_cos; + +if (!strcasecmp(function_name->value, "TAN")) + return function_tan; + +if (!strcasecmp(function_name->value, "ASIN")) + return function_asin; + +if (!strcasecmp(function_name->value, "ACOS")) + return function_acos; + +if (!strcasecmp(function_name->value, "ATAN")) + return function_atan; + +if (!strcasecmp(function_name->value, "ADD")) + return function_add; + +if (!strcasecmp(function_name->value, "MUL")) + return function_mul; + +if (!strcasecmp(function_name->value, "SUB")) + return function_sub; + +if (!strcasecmp(function_name->value, "DIV")) + return function_div; + +if (!strcasecmp(function_name->value, "MOD")) + return function_mod; + +if (!strcasecmp(function_name->value, "EXPT")) + return function_expt; + +if (!strcasecmp(function_name->value, "MOVE")) + return function_move; + +if (!strcasecmp(function_name->value, "SHL")) + return function_shl; + +if (!strcasecmp(function_name->value, "SHR")) + return function_shr; + +if (!strcasecmp(function_name->value, "ROR")) + return function_ror; + +if (!strcasecmp(function_name->value, "ROL")) + return function_rol; + +if (!strcasecmp(function_name->value, "AND")) + return function_and; + +if (!strcasecmp(function_name->value, "OR")) + return function_or; + +if (!strcasecmp(function_name->value, "XOR")) + return function_xor; + +if (!strcasecmp(function_name->value, "NOT")) + return function_not; + +if (!strcasecmp(function_name->value, "SEL")) + return function_sel; + +if (!strcasecmp(function_name->value, "MAX")) + return function_max; + +if (!strcasecmp(function_name->value, "MIN")) + return function_min; + +if (!strcasecmp(function_name->value, "LIMIT")) + return function_limit; + +if (!strcasecmp(function_name->value, "MUX")) + return function_mux; + +if (!strcasecmp(function_name->value, "GT")) + return function_gt; + +if (!strcasecmp(function_name->value, "GE")) + return function_ge; + +if (!strcasecmp(function_name->value, "EQ")) + return function_eq; + +if (!strcasecmp(function_name->value, "LT")) + return function_lt; + +if (!strcasecmp(function_name->value, "LE")) + return function_le; + +if (!strcasecmp(function_name->value, "NE")) + return function_ne; + +if (!strcasecmp(function_name->value, "LEN")) + return function_len; + +if (!strcasecmp(function_name->value, "LEFT")) + return function_left; + +if (!strcasecmp(function_name->value, "RIGHT")) + return function_right; + +if (!strcasecmp(function_name->value, "MID")) + return function_mid; + +if (!strcasecmp(function_name->value, "CONCAT")) + return function_concat; + +if (!strcasecmp(function_name->value, "INSERT")) + return function_insert; + +if (!strcasecmp(function_name->value, "DELETE")) + return function_delete; + +if (!strcasecmp(function_name->value, "REPLACE")) + return function_replace; + +if (!strcasecmp(function_name->value, "FIND")) + return function_find; + + else return function_none; +} + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/il_code_gen.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/il_code_gen.c Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,15289 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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 lib + * generated code, do not edit by hand + */ +switch(current_function_type){ + +/**** + *BOOL_TO_SINT + */ + case function_bool_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_sint*/ + break; + +/**** + *BOOL_TO_INT + */ + case function_bool_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_int*/ + break; + +/**** + *BOOL_TO_DINT + */ + case function_bool_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_dint*/ + break; + +/**** + *BOOL_TO_LINT + */ + case function_bool_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_lint*/ + break; + +/**** + *BOOL_TO_USINT + */ + case function_bool_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_usint*/ + break; + +/**** + *BOOL_TO_UINT + */ + case function_bool_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_uint*/ + break; + +/**** + *BOOL_TO_UDINT + */ + case function_bool_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_udint*/ + break; + +/**** + *BOOL_TO_ULINT + */ + case function_bool_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_ulint*/ + break; + +/**** + *BOOL_TO_REAL + */ + case function_bool_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_real*/ + break; + +/**** + *BOOL_TO_LREAL + */ + case function_bool_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_lreal*/ + break; + +/**** + *BOOL_TO_TIME + */ + case function_bool_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_time*/ + break; + +/**** + *BOOL_TO_DATE + */ + case function_bool_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_date*/ + break; + +/**** + *BOOL_TO_TOD + */ + case function_bool_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_tod*/ + break; + +/**** + *BOOL_TO_DT + */ + case function_bool_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_dt*/ + break; + +/**** + *BOOL_TO_STRING + */ + case function_bool_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bool_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_string*/ + break; + +/**** + *BOOL_TO_BYTE + */ + case function_bool_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_byte*/ + break; + +/**** + *BOOL_TO_WORD + */ + case function_bool_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_word*/ + break; + +/**** + *BOOL_TO_DWORD + */ + case function_bool_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_dword*/ + break; + +/**** + *BOOL_TO_LWORD + */ + case function_bool_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_lword*/ + break; + +/**** + *SINT_TO_BOOL + */ + case function_sint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_bool*/ + break; + +/**** + *SINT_TO_INT + */ + case function_sint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_int*/ + break; + +/**** + *SINT_TO_DINT + */ + case function_sint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_dint*/ + break; + +/**** + *SINT_TO_LINT + */ + case function_sint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_lint*/ + break; + +/**** + *SINT_TO_USINT + */ + case function_sint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_usint*/ + break; + +/**** + *SINT_TO_UINT + */ + case function_sint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_uint*/ + break; + +/**** + *SINT_TO_UDINT + */ + case function_sint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_udint*/ + break; + +/**** + *SINT_TO_ULINT + */ + case function_sint_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_ulint*/ + break; + +/**** + *SINT_TO_REAL + */ + case function_sint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_real*/ + break; + +/**** + *SINT_TO_LREAL + */ + case function_sint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_lreal*/ + break; + +/**** + *SINT_TO_TIME + */ + case function_sint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_time*/ + break; + +/**** + *SINT_TO_DATE + */ + case function_sint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_date*/ + break; + +/**** + *SINT_TO_TOD + */ + case function_sint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_tod*/ + break; + +/**** + *SINT_TO_DT + */ + case function_sint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_dt*/ + break; + +/**** + *SINT_TO_STRING + */ + case function_sint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__sint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_string*/ + break; + +/**** + *SINT_TO_BYTE + */ + case function_sint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_byte*/ + break; + +/**** + *SINT_TO_WORD + */ + case function_sint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_word*/ + break; + +/**** + *SINT_TO_DWORD + */ + case function_sint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_dword*/ + break; + +/**** + *SINT_TO_LWORD + */ + case function_sint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_lword*/ + break; + +/**** + *INT_TO_BOOL + */ + case function_int_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_bool*/ + break; + +/**** + *INT_TO_SINT + */ + case function_int_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_sint*/ + break; + +/**** + *INT_TO_DINT + */ + case function_int_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_dint*/ + break; + +/**** + *INT_TO_LINT + */ + case function_int_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_lint*/ + break; + +/**** + *INT_TO_USINT + */ + case function_int_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_usint*/ + break; + +/**** + *INT_TO_UINT + */ + case function_int_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_uint*/ + break; + +/**** + *INT_TO_UDINT + */ + case function_int_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_udint*/ + break; + +/**** + *INT_TO_ULINT + */ + case function_int_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_ulint*/ + break; + +/**** + *INT_TO_REAL + */ + case function_int_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_real*/ + break; + +/**** + *INT_TO_LREAL + */ + case function_int_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_lreal*/ + break; + +/**** + *INT_TO_TIME + */ + case function_int_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_time*/ + break; + +/**** + *INT_TO_DATE + */ + case function_int_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_date*/ + break; + +/**** + *INT_TO_TOD + */ + case function_int_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_tod*/ + break; + +/**** + *INT_TO_DT + */ + case function_int_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_dt*/ + break; + +/**** + *INT_TO_STRING + */ + case function_int_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__sint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_string*/ + break; + +/**** + *INT_TO_BYTE + */ + case function_int_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_byte*/ + break; + +/**** + *INT_TO_WORD + */ + case function_int_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_word*/ + break; + +/**** + *INT_TO_DWORD + */ + case function_int_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_dword*/ + break; + +/**** + *INT_TO_LWORD + */ + case function_int_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_lword*/ + break; + +/**** + *DINT_TO_BOOL + */ + case function_dint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_bool*/ + break; + +/**** + *DINT_TO_SINT + */ + case function_dint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_sint*/ + break; + +/**** + *DINT_TO_INT + */ + case function_dint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_int*/ + break; + +/**** + *DINT_TO_LINT + */ + case function_dint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_lint*/ + break; + +/**** + *DINT_TO_USINT + */ + case function_dint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_usint*/ + break; + +/**** + *DINT_TO_UINT + */ + case function_dint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_uint*/ + break; + +/**** + *DINT_TO_UDINT + */ + case function_dint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_udint*/ + break; + +/**** + *DINT_TO_ULINT + */ + case function_dint_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_ulint*/ + break; + +/**** + *DINT_TO_REAL + */ + case function_dint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_real*/ + break; + +/**** + *DINT_TO_LREAL + */ + case function_dint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_lreal*/ + break; + +/**** + *DINT_TO_TIME + */ + case function_dint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_time*/ + break; + +/**** + *DINT_TO_DATE + */ + case function_dint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_date*/ + break; + +/**** + *DINT_TO_TOD + */ + case function_dint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_tod*/ + break; + +/**** + *DINT_TO_DT + */ + case function_dint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_dt*/ + break; + +/**** + *DINT_TO_STRING + */ + case function_dint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__sint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_string*/ + break; + +/**** + *DINT_TO_BYTE + */ + case function_dint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_byte*/ + break; + +/**** + *DINT_TO_WORD + */ + case function_dint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_word*/ + break; + +/**** + *DINT_TO_DWORD + */ + case function_dint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_dword*/ + break; + +/**** + *DINT_TO_LWORD + */ + case function_dint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_lword*/ + break; + +/**** + *LINT_TO_BOOL + */ + case function_lint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_bool*/ + break; + +/**** + *LINT_TO_SINT + */ + case function_lint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_sint*/ + break; + +/**** + *LINT_TO_INT + */ + case function_lint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_int*/ + break; + +/**** + *LINT_TO_DINT + */ + case function_lint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_dint*/ + break; + +/**** + *LINT_TO_USINT + */ + case function_lint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_usint*/ + break; + +/**** + *LINT_TO_UINT + */ + case function_lint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_uint*/ + break; + +/**** + *LINT_TO_UDINT + */ + case function_lint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_udint*/ + break; + +/**** + *LINT_TO_ULINT + */ + case function_lint_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_ulint*/ + break; + +/**** + *LINT_TO_REAL + */ + case function_lint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_real*/ + break; + +/**** + *LINT_TO_LREAL + */ + case function_lint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_lreal*/ + break; + +/**** + *LINT_TO_TIME + */ + case function_lint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_time*/ + break; + +/**** + *LINT_TO_DATE + */ + case function_lint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_date*/ + break; + +/**** + *LINT_TO_TOD + */ + case function_lint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_tod*/ + break; + +/**** + *LINT_TO_DT + */ + case function_lint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_dt*/ + break; + +/**** + *LINT_TO_STRING + */ + case function_lint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__sint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_string*/ + break; + +/**** + *LINT_TO_BYTE + */ + case function_lint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_byte*/ + break; + +/**** + *LINT_TO_WORD + */ + case function_lint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_word*/ + break; + +/**** + *LINT_TO_DWORD + */ + case function_lint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_dword*/ + break; + +/**** + *LINT_TO_LWORD + */ + case function_lint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_lword*/ + break; + +/**** + *USINT_TO_BOOL + */ + case function_usint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_bool*/ + break; + +/**** + *USINT_TO_SINT + */ + case function_usint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_sint*/ + break; + +/**** + *USINT_TO_INT + */ + case function_usint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_int*/ + break; + +/**** + *USINT_TO_DINT + */ + case function_usint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_dint*/ + break; + +/**** + *USINT_TO_LINT + */ + case function_usint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_lint*/ + break; + +/**** + *USINT_TO_UINT + */ + case function_usint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_uint*/ + break; + +/**** + *USINT_TO_UDINT + */ + case function_usint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_udint*/ + break; + +/**** + *USINT_TO_ULINT + */ + case function_usint_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_ulint*/ + break; + +/**** + *USINT_TO_REAL + */ + case function_usint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_real*/ + break; + +/**** + *USINT_TO_LREAL + */ + case function_usint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_lreal*/ + break; + +/**** + *USINT_TO_TIME + */ + case function_usint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_time*/ + break; + +/**** + *USINT_TO_DATE + */ + case function_usint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_date*/ + break; + +/**** + *USINT_TO_TOD + */ + case function_usint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_tod*/ + break; + +/**** + *USINT_TO_DT + */ + case function_usint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_dt*/ + break; + +/**** + *USINT_TO_STRING + */ + case function_usint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_string*/ + break; + +/**** + *USINT_TO_BYTE + */ + case function_usint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_byte*/ + break; + +/**** + *USINT_TO_WORD + */ + case function_usint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_word*/ + break; + +/**** + *USINT_TO_DWORD + */ + case function_usint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_dword*/ + break; + +/**** + *USINT_TO_LWORD + */ + case function_usint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_lword*/ + break; + +/**** + *UINT_TO_BOOL + */ + case function_uint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_bool*/ + break; + +/**** + *UINT_TO_SINT + */ + case function_uint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_sint*/ + break; + +/**** + *UINT_TO_INT + */ + case function_uint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_int*/ + break; + +/**** + *UINT_TO_DINT + */ + case function_uint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_dint*/ + break; + +/**** + *UINT_TO_LINT + */ + case function_uint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_lint*/ + break; + +/**** + *UINT_TO_USINT + */ + case function_uint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_usint*/ + break; + +/**** + *UINT_TO_UDINT + */ + case function_uint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_udint*/ + break; + +/**** + *UINT_TO_ULINT + */ + case function_uint_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_ulint*/ + break; + +/**** + *UINT_TO_REAL + */ + case function_uint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_real*/ + break; + +/**** + *UINT_TO_LREAL + */ + case function_uint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_lreal*/ + break; + +/**** + *UINT_TO_TIME + */ + case function_uint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_time*/ + break; + +/**** + *UINT_TO_DATE + */ + case function_uint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_date*/ + break; + +/**** + *UINT_TO_TOD + */ + case function_uint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_tod*/ + break; + +/**** + *UINT_TO_DT + */ + case function_uint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_dt*/ + break; + +/**** + *UINT_TO_STRING + */ + case function_uint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_string*/ + break; + +/**** + *UINT_TO_BYTE + */ + case function_uint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_byte*/ + break; + +/**** + *UINT_TO_WORD + */ + case function_uint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_word*/ + break; + +/**** + *UINT_TO_DWORD + */ + case function_uint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_dword*/ + break; + +/**** + *UINT_TO_LWORD + */ + case function_uint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_lword*/ + break; + +/**** + *UDINT_TO_BOOL + */ + case function_udint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_bool*/ + break; + +/**** + *UDINT_TO_SINT + */ + case function_udint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_sint*/ + break; + +/**** + *UDINT_TO_INT + */ + case function_udint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_int*/ + break; + +/**** + *UDINT_TO_DINT + */ + case function_udint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_dint*/ + break; + +/**** + *UDINT_TO_LINT + */ + case function_udint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_lint*/ + break; + +/**** + *UDINT_TO_USINT + */ + case function_udint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_usint*/ + break; + +/**** + *UDINT_TO_UINT + */ + case function_udint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_uint*/ + break; + +/**** + *UDINT_TO_ULINT + */ + case function_udint_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_ulint*/ + break; + +/**** + *UDINT_TO_REAL + */ + case function_udint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_real*/ + break; + +/**** + *UDINT_TO_LREAL + */ + case function_udint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_lreal*/ + break; + +/**** + *UDINT_TO_TIME + */ + case function_udint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_time*/ + break; + +/**** + *UDINT_TO_DATE + */ + case function_udint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_date*/ + break; + +/**** + *UDINT_TO_TOD + */ + case function_udint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_tod*/ + break; + +/**** + *UDINT_TO_DT + */ + case function_udint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_dt*/ + break; + +/**** + *UDINT_TO_STRING + */ + case function_udint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_string*/ + break; + +/**** + *UDINT_TO_BYTE + */ + case function_udint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_byte*/ + break; + +/**** + *UDINT_TO_WORD + */ + case function_udint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_word*/ + break; + +/**** + *UDINT_TO_DWORD + */ + case function_udint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_dword*/ + break; + +/**** + *UDINT_TO_LWORD + */ + case function_udint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_lword*/ + break; + +/**** + *ULINT_TO_BOOL + */ + case function_ulint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_bool*/ + break; + +/**** + *ULINT_TO_SINT + */ + case function_ulint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_sint*/ + break; + +/**** + *ULINT_TO_INT + */ + case function_ulint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_int*/ + break; + +/**** + *ULINT_TO_DINT + */ + case function_ulint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_dint*/ + break; + +/**** + *ULINT_TO_LINT + */ + case function_ulint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_lint*/ + break; + +/**** + *ULINT_TO_USINT + */ + case function_ulint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_usint*/ + break; + +/**** + *ULINT_TO_UINT + */ + case function_ulint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_uint*/ + break; + +/**** + *ULINT_TO_UDINT + */ + case function_ulint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_udint*/ + break; + +/**** + *ULINT_TO_REAL + */ + case function_ulint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_real*/ + break; + +/**** + *ULINT_TO_LREAL + */ + case function_ulint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_lreal*/ + break; + +/**** + *ULINT_TO_TIME + */ + case function_ulint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_time*/ + break; + +/**** + *ULINT_TO_DATE + */ + case function_ulint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_date*/ + break; + +/**** + *ULINT_TO_TOD + */ + case function_ulint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_tod*/ + break; + +/**** + *ULINT_TO_DT + */ + case function_ulint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_dt*/ + break; + +/**** + *ULINT_TO_STRING + */ + case function_ulint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_string*/ + break; + +/**** + *ULINT_TO_BYTE + */ + case function_ulint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_byte*/ + break; + +/**** + *ULINT_TO_WORD + */ + case function_ulint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_word*/ + break; + +/**** + *ULINT_TO_DWORD + */ + case function_ulint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_dword*/ + break; + +/**** + *ULINT_TO_LWORD + */ + case function_ulint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_lword*/ + break; + +/**** + *REAL_TO_BOOL + */ + case function_real_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_bool*/ + break; + +/**** + *REAL_TO_SINT + */ + case function_real_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_sint*/ + break; + +/**** + *REAL_TO_INT + */ + case function_real_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_int*/ + break; + +/**** + *REAL_TO_DINT + */ + case function_real_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_dint*/ + break; + +/**** + *REAL_TO_LINT + */ + case function_real_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_lint*/ + break; + +/**** + *REAL_TO_USINT + */ + case function_real_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_usint*/ + break; + +/**** + *REAL_TO_UINT + */ + case function_real_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_uint*/ + break; + +/**** + *REAL_TO_UDINT + */ + case function_real_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_udint*/ + break; + +/**** + *REAL_TO_ULINT + */ + case function_real_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_ulint*/ + break; + +/**** + *REAL_TO_LREAL + */ + case function_real_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_lreal*/ + break; + +/**** + *REAL_TO_TIME + */ + case function_real_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_time*/ + break; + +/**** + *REAL_TO_DATE + */ + case function_real_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_date*/ + break; + +/**** + *REAL_TO_TOD + */ + case function_real_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_tod*/ + break; + +/**** + *REAL_TO_DT + */ + case function_real_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_dt*/ + break; + +/**** + *REAL_TO_STRING + */ + case function_real_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_string*/ + break; + +/**** + *REAL_TO_BYTE + */ + case function_real_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_byte*/ + break; + +/**** + *REAL_TO_WORD + */ + case function_real_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_word*/ + break; + +/**** + *REAL_TO_DWORD + */ + case function_real_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_dword*/ + break; + +/**** + *REAL_TO_LWORD + */ + case function_real_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_lword*/ + break; + +/**** + *LREAL_TO_BOOL + */ + case function_lreal_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_bool*/ + break; + +/**** + *LREAL_TO_SINT + */ + case function_lreal_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_sint*/ + break; + +/**** + *LREAL_TO_INT + */ + case function_lreal_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_int*/ + break; + +/**** + *LREAL_TO_DINT + */ + case function_lreal_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_dint*/ + break; + +/**** + *LREAL_TO_LINT + */ + case function_lreal_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_lint*/ + break; + +/**** + *LREAL_TO_USINT + */ + case function_lreal_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_usint*/ + break; + +/**** + *LREAL_TO_UINT + */ + case function_lreal_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_uint*/ + break; + +/**** + *LREAL_TO_UDINT + */ + case function_lreal_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_udint*/ + break; + +/**** + *LREAL_TO_ULINT + */ + case function_lreal_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_ulint*/ + break; + +/**** + *LREAL_TO_REAL + */ + case function_lreal_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_real*/ + break; + +/**** + *LREAL_TO_TIME + */ + case function_lreal_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_time*/ + break; + +/**** + *LREAL_TO_DATE + */ + case function_lreal_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_date*/ + break; + +/**** + *LREAL_TO_TOD + */ + case function_lreal_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_tod*/ + break; + +/**** + *LREAL_TO_DT + */ + case function_lreal_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_dt*/ + break; + +/**** + *LREAL_TO_STRING + */ + case function_lreal_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_string*/ + break; + +/**** + *LREAL_TO_BYTE + */ + case function_lreal_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_byte*/ + break; + +/**** + *LREAL_TO_WORD + */ + case function_lreal_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_word*/ + break; + +/**** + *LREAL_TO_DWORD + */ + case function_lreal_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_dword*/ + break; + +/**** + *LREAL_TO_LWORD + */ + case function_lreal_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_lword*/ + break; + +/**** + *TIME_TO_SINT + */ + case function_time_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_sint*/ + break; + +/**** + *TIME_TO_INT + */ + case function_time_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_int*/ + break; + +/**** + *TIME_TO_DINT + */ + case function_time_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_dint*/ + break; + +/**** + *TIME_TO_LINT + */ + case function_time_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_lint*/ + break; + +/**** + *TIME_TO_USINT + */ + case function_time_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_usint*/ + break; + +/**** + *TIME_TO_UINT + */ + case function_time_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_uint*/ + break; + +/**** + *TIME_TO_UDINT + */ + case function_time_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_udint*/ + break; + +/**** + *TIME_TO_ULINT + */ + case function_time_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_ulint*/ + break; + +/**** + *TIME_TO_REAL + */ + case function_time_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_real*/ + break; + +/**** + *TIME_TO_LREAL + */ + case function_time_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_lreal*/ + break; + +/**** + *TIME_TO_STRING + */ + case function_time_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_string*/ + break; + +/**** + *TIME_TO_BYTE + */ + case function_time_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_byte*/ + break; + +/**** + *TIME_TO_WORD + */ + case function_time_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_word*/ + break; + +/**** + *TIME_TO_DWORD + */ + case function_time_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_dword*/ + break; + +/**** + *TIME_TO_LWORD + */ + case function_time_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_lword*/ + break; + +/**** + *DATE_TO_SINT + */ + case function_date_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_sint*/ + break; + +/**** + *DATE_TO_INT + */ + case function_date_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_int*/ + break; + +/**** + *DATE_TO_DINT + */ + case function_date_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_dint*/ + break; + +/**** + *DATE_TO_LINT + */ + case function_date_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_lint*/ + break; + +/**** + *DATE_TO_USINT + */ + case function_date_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_usint*/ + break; + +/**** + *DATE_TO_UINT + */ + case function_date_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_uint*/ + break; + +/**** + *DATE_TO_UDINT + */ + case function_date_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_udint*/ + break; + +/**** + *DATE_TO_ULINT + */ + case function_date_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_ulint*/ + break; + +/**** + *DATE_TO_REAL + */ + case function_date_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_real*/ + break; + +/**** + *DATE_TO_LREAL + */ + case function_date_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_lreal*/ + break; + +/**** + *DATE_TO_STRING + */ + case function_date_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__date_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_string*/ + break; + +/**** + *DATE_TO_BYTE + */ + case function_date_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_byte*/ + break; + +/**** + *DATE_TO_WORD + */ + case function_date_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_word*/ + break; + +/**** + *DATE_TO_DWORD + */ + case function_date_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_dword*/ + break; + +/**** + *DATE_TO_LWORD + */ + case function_date_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_lword*/ + break; + +/**** + *TOD_TO_SINT + */ + case function_tod_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_sint*/ + break; + +/**** + *TOD_TO_INT + */ + case function_tod_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_int*/ + break; + +/**** + *TOD_TO_DINT + */ + case function_tod_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_dint*/ + break; + +/**** + *TOD_TO_LINT + */ + case function_tod_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_lint*/ + break; + +/**** + *TOD_TO_USINT + */ + case function_tod_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_usint*/ + break; + +/**** + *TOD_TO_UINT + */ + case function_tod_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_uint*/ + break; + +/**** + *TOD_TO_UDINT + */ + case function_tod_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_udint*/ + break; + +/**** + *TOD_TO_ULINT + */ + case function_tod_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_ulint*/ + break; + +/**** + *TOD_TO_REAL + */ + case function_tod_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_real*/ + break; + +/**** + *TOD_TO_LREAL + */ + case function_tod_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_lreal*/ + break; + +/**** + *TOD_TO_STRING + */ + case function_tod_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__tod_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_string*/ + break; + +/**** + *TOD_TO_BYTE + */ + case function_tod_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_byte*/ + break; + +/**** + *TOD_TO_WORD + */ + case function_tod_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_word*/ + break; + +/**** + *TOD_TO_DWORD + */ + case function_tod_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_dword*/ + break; + +/**** + *TOD_TO_LWORD + */ + case function_tod_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_lword*/ + break; + +/**** + *DT_TO_SINT + */ + case function_dt_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_sint*/ + break; + +/**** + *DT_TO_INT + */ + case function_dt_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_int*/ + break; + +/**** + *DT_TO_DINT + */ + case function_dt_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_dint*/ + break; + +/**** + *DT_TO_LINT + */ + case function_dt_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_lint*/ + break; + +/**** + *DT_TO_USINT + */ + case function_dt_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_usint*/ + break; + +/**** + *DT_TO_UINT + */ + case function_dt_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_uint*/ + break; + +/**** + *DT_TO_UDINT + */ + case function_dt_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_udint*/ + break; + +/**** + *DT_TO_ULINT + */ + case function_dt_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_ulint*/ + break; + +/**** + *DT_TO_REAL + */ + case function_dt_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_real*/ + break; + +/**** + *DT_TO_LREAL + */ + case function_dt_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_lreal*/ + break; + +/**** + *DT_TO_STRING + */ + case function_dt_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__dt_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_string*/ + break; + +/**** + *DT_TO_BYTE + */ + case function_dt_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_byte*/ + break; + +/**** + *DT_TO_WORD + */ + case function_dt_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_word*/ + break; + +/**** + *DT_TO_DWORD + */ + case function_dt_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_dword*/ + break; + +/**** + *DT_TO_LWORD + */ + case function_dt_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_lword*/ + break; + +/**** + *STRING_TO_BOOL + */ + case function_string_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_bool("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_bool*/ + break; + +/**** + *STRING_TO_SINT + */ + case function_string_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_sint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_sint*/ + break; + +/**** + *STRING_TO_INT + */ + case function_string_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_sint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_int*/ + break; + +/**** + *STRING_TO_DINT + */ + case function_string_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_sint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_dint*/ + break; + +/**** + *STRING_TO_LINT + */ + case function_string_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_sint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_lint*/ + break; + +/**** + *STRING_TO_USINT + */ + case function_string_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_usint*/ + break; + +/**** + *STRING_TO_UINT + */ + case function_string_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_uint*/ + break; + +/**** + *STRING_TO_UDINT + */ + case function_string_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_udint*/ + break; + +/**** + *STRING_TO_ULINT + */ + case function_string_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_ulint*/ + break; + +/**** + *STRING_TO_REAL + */ + case function_string_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_real*/ + break; + +/**** + *STRING_TO_LREAL + */ + case function_string_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_lreal*/ + break; + +/**** + *STRING_TO_TIME + */ + case function_string_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_time*/ + break; + +/**** + *STRING_TO_DATE + */ + case function_string_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_date*/ + break; + +/**** + *STRING_TO_TOD + */ + case function_string_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_tod*/ + break; + +/**** + *STRING_TO_DT + */ + case function_string_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_dt*/ + break; + +/**** + *STRING_TO_BYTE + */ + case function_string_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_bit("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_byte*/ + break; + +/**** + *STRING_TO_WORD + */ + case function_string_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_bit("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_word*/ + break; + +/**** + *STRING_TO_DWORD + */ + case function_string_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_bit("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_dword*/ + break; + +/**** + *STRING_TO_LWORD + */ + case function_string_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_bit("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_lword*/ + break; + +/**** + *BYTE_TO_BOOL + */ + case function_byte_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_bool*/ + break; + +/**** + *BYTE_TO_SINT + */ + case function_byte_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_sint*/ + break; + +/**** + *BYTE_TO_INT + */ + case function_byte_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_int*/ + break; + +/**** + *BYTE_TO_DINT + */ + case function_byte_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_dint*/ + break; + +/**** + *BYTE_TO_LINT + */ + case function_byte_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_lint*/ + break; + +/**** + *BYTE_TO_USINT + */ + case function_byte_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_usint*/ + break; + +/**** + *BYTE_TO_UINT + */ + case function_byte_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_uint*/ + break; + +/**** + *BYTE_TO_UDINT + */ + case function_byte_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_udint*/ + break; + +/**** + *BYTE_TO_ULINT + */ + case function_byte_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_ulint*/ + break; + +/**** + *BYTE_TO_REAL + */ + case function_byte_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_real*/ + break; + +/**** + *BYTE_TO_LREAL + */ + case function_byte_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_lreal*/ + break; + +/**** + *BYTE_TO_TIME + */ + case function_byte_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_time*/ + break; + +/**** + *BYTE_TO_DATE + */ + case function_byte_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_date*/ + break; + +/**** + *BYTE_TO_TOD + */ + case function_byte_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_tod*/ + break; + +/**** + *BYTE_TO_DT + */ + case function_byte_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_dt*/ + break; + +/**** + *BYTE_TO_STRING + */ + case function_byte_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bit_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_string*/ + break; + +/**** + *BYTE_TO_WORD + */ + case function_byte_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_word*/ + break; + +/**** + *BYTE_TO_DWORD + */ + case function_byte_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_dword*/ + break; + +/**** + *BYTE_TO_LWORD + */ + case function_byte_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_lword*/ + break; + +/**** + *WORD_TO_BOOL + */ + case function_word_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_bool*/ + break; + +/**** + *WORD_TO_SINT + */ + case function_word_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_sint*/ + break; + +/**** + *WORD_TO_INT + */ + case function_word_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_int*/ + break; + +/**** + *WORD_TO_DINT + */ + case function_word_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_dint*/ + break; + +/**** + *WORD_TO_LINT + */ + case function_word_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_lint*/ + break; + +/**** + *WORD_TO_USINT + */ + case function_word_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_usint*/ + break; + +/**** + *WORD_TO_UINT + */ + case function_word_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_uint*/ + break; + +/**** + *WORD_TO_UDINT + */ + case function_word_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_udint*/ + break; + +/**** + *WORD_TO_ULINT + */ + case function_word_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_ulint*/ + break; + +/**** + *WORD_TO_REAL + */ + case function_word_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_real*/ + break; + +/**** + *WORD_TO_LREAL + */ + case function_word_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_lreal*/ + break; + +/**** + *WORD_TO_TIME + */ + case function_word_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_time*/ + break; + +/**** + *WORD_TO_DATE + */ + case function_word_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_date*/ + break; + +/**** + *WORD_TO_TOD + */ + case function_word_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_tod*/ + break; + +/**** + *WORD_TO_DT + */ + case function_word_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_dt*/ + break; + +/**** + *WORD_TO_STRING + */ + case function_word_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bit_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_string*/ + break; + +/**** + *WORD_TO_BYTE + */ + case function_word_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_byte*/ + break; + +/**** + *WORD_TO_DWORD + */ + case function_word_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_dword*/ + break; + +/**** + *WORD_TO_LWORD + */ + case function_word_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_lword*/ + break; + +/**** + *DWORD_TO_BOOL + */ + case function_dword_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_bool*/ + break; + +/**** + *DWORD_TO_SINT + */ + case function_dword_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_sint*/ + break; + +/**** + *DWORD_TO_INT + */ + case function_dword_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_int*/ + break; + +/**** + *DWORD_TO_DINT + */ + case function_dword_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_dint*/ + break; + +/**** + *DWORD_TO_LINT + */ + case function_dword_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_lint*/ + break; + +/**** + *DWORD_TO_USINT + */ + case function_dword_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_usint*/ + break; + +/**** + *DWORD_TO_UINT + */ + case function_dword_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_uint*/ + break; + +/**** + *DWORD_TO_UDINT + */ + case function_dword_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_udint*/ + break; + +/**** + *DWORD_TO_ULINT + */ + case function_dword_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_ulint*/ + break; + +/**** + *DWORD_TO_REAL + */ + case function_dword_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_real*/ + break; + +/**** + *DWORD_TO_LREAL + */ + case function_dword_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_lreal*/ + break; + +/**** + *DWORD_TO_TIME + */ + case function_dword_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_time*/ + break; + +/**** + *DWORD_TO_DATE + */ + case function_dword_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_date*/ + break; + +/**** + *DWORD_TO_TOD + */ + case function_dword_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_tod*/ + break; + +/**** + *DWORD_TO_DT + */ + case function_dword_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_dt*/ + break; + +/**** + *DWORD_TO_STRING + */ + case function_dword_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bit_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_string*/ + break; + +/**** + *DWORD_TO_BYTE + */ + case function_dword_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_byte*/ + break; + +/**** + *DWORD_TO_WORD + */ + case function_dword_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_word*/ + break; + +/**** + *DWORD_TO_LWORD + */ + case function_dword_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_lword*/ + break; + +/**** + *LWORD_TO_BOOL + */ + case function_lword_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_bool*/ + break; + +/**** + *LWORD_TO_SINT + */ + case function_lword_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_sint*/ + break; + +/**** + *LWORD_TO_INT + */ + case function_lword_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_int*/ + break; + +/**** + *LWORD_TO_DINT + */ + case function_lword_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_dint*/ + break; + +/**** + *LWORD_TO_LINT + */ + case function_lword_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_lint*/ + break; + +/**** + *LWORD_TO_USINT + */ + case function_lword_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_usint*/ + break; + +/**** + *LWORD_TO_UINT + */ + case function_lword_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_uint*/ + break; + +/**** + *LWORD_TO_UDINT + */ + case function_lword_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_udint*/ + break; + +/**** + *LWORD_TO_ULINT + */ + case function_lword_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_ulint*/ + break; + +/**** + *LWORD_TO_REAL + */ + case function_lword_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_real*/ + break; + +/**** + *LWORD_TO_LREAL + */ + case function_lword_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_lreal*/ + break; + +/**** + *LWORD_TO_TIME + */ + case function_lword_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_time*/ + break; + +/**** + *LWORD_TO_DATE + */ + case function_lword_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_date*/ + break; + +/**** + *LWORD_TO_TOD + */ + case function_lword_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_tod*/ + break; + +/**** + *LWORD_TO_DT + */ + case function_lword_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_dt*/ + break; + +/**** + *LWORD_TO_STRING + */ + case function_lword_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bit_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_string*/ + break; + +/**** + *LWORD_TO_BYTE + */ + case function_lword_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_byte*/ + break; + +/**** + *LWORD_TO_WORD + */ + case function_lword_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_word*/ + break; + +/**** + *LWORD_TO_DWORD + */ + case function_lword_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_dword*/ + break; + +/**** + *TRUNC + */ + case function_trunc : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + s4o.print("(int)"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_trunc*/ + break; + +/**** + *BCD_TO_USINT + */ + case function_bcd_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bcd_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bcd_to_usint*/ + break; + +/**** + *BCD_TO_UINT + */ + case function_bcd_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bcd_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bcd_to_uint*/ + break; + +/**** + *BCD_TO_UDINT + */ + case function_bcd_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bcd_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bcd_to_udint*/ + break; + +/**** + *BCD_TO_ULINT + */ + case function_bcd_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bcd_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bcd_to_ulint*/ + break; + +/**** + *USINT_TO_BCD + */ + case function_usint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_bcd("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_bcd*/ + break; + +/**** + *UINT_TO_BCD + */ + case function_uint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_bcd("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_bcd*/ + break; + +/**** + *UDINT_TO_BCD + */ + case function_udint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_bcd("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_bcd*/ + break; + +/**** + *ULINT_TO_BCD + */ + case function_ulint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_bcd("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_bcd*/ + break; + +/**** + *DATE_AND_TIME_TO_TIME_OF_DAY + */ + case function_date_and_time_to_time_of_day : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("__date_and_time_to_time_of_day("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_and_time_to_time_of_day*/ + break; + +/**** + *DATE_AND_TIME_TO_DATE + */ + case function_date_and_time_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("__date_and_time_to_date("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_and_time_to_date*/ + break; + +/**** + *ABS + */ + case function_abs : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("__abs_"); + IN_type_symbol->accept(*this); + s4o.print("("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_abs*/ + break; + +/**** + *SQRT + */ + case function_sqrt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("sqrt("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sqrt*/ + break; + +/**** + *LN + */ + case function_ln : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("ln("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ln*/ + break; + +/**** + *LOG + */ + case function_log : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("log("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_log*/ + break; + +/**** + *EXP + */ + case function_exp : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("exp("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_exp*/ + break; + +/**** + *SIN + */ + case function_sin : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("sin("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sin*/ + break; + +/**** + *COS + */ + case function_cos : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("cos("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_cos*/ + break; + +/**** + *TAN + */ + case function_tan : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("tan("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tan*/ + break; + +/**** + *ASIN + */ + case function_asin : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("asin("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_asin*/ + break; + +/**** + *ACOS + */ + case function_acos : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("acos("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_acos*/ + break; + +/**** + *ATAN + */ + case function_atan : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("atan("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_atan*/ + break; + +/**** + *ADD + */ + case function_add : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("+\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print("+\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("__time_add("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("__time_add("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_add("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_add*/ + break; + +/**** + *MUL + */ + case function_mul : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("*\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print("*\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_mul("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mul*/ + break; + +/**** + *SUB + */ + case function_sub : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("-\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_sub("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_sub("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("__time_sub("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_sub("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("__time_sub("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_sub("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_sub*/ + break; + +/**** + *DIV + */ + case function_div : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("/\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_div("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_div*/ + break; + +/**** + *MOD + */ + case function_mod : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("%\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mod*/ + break; + +/**** + *EXPT + */ + case function_expt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.print("pow("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_expt*/ + break; + +/**** + *MOVE + */ + case function_move : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_move*/ + break; + +/**** + *SHL + */ + case function_shl : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_binary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + IN_param_value->accept(*this); + s4o.print("<<"); + N_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_shl*/ + break; + +/**** + *SHR + */ + case function_shr : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_binary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + IN_param_value->accept(*this); + s4o.print(">>"); + N_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_shr*/ + break; + +/**** + *ROR + */ + case function_ror : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_nbinary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("__ror_"); + IN_type_symbol->accept(*this); + s4o.print("("); + IN_param_value->accept(*this); + s4o.print(", "); + N_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_ror*/ + break; + +/**** + *ROL + */ + case function_rol : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_nbinary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("__rol_"); + IN_type_symbol->accept(*this); + s4o.print("("); + IN_param_value->accept(*this); + s4o.print(", "); + N_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_rol*/ + break; + +/**** + *AND + */ + case function_and : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_binary_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_binary_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("("); + if (search_expression_type->is_bool_type(last_type_symbol)) + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("&\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print("&\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + if (search_expression_type->is_bool_type(last_type_symbol)) { + s4o.print("&1"); + s4o.print(")"); + } + s4o.print(""); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_and*/ + break; + +/**** + *OR + */ + case function_or : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_binary_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_binary_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("("); + if (search_expression_type->is_bool_type(last_type_symbol)) + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("|\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print("|\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + if (search_expression_type->is_bool_type(last_type_symbol)) { + s4o.print("&1"); + s4o.print(")"); + } + s4o.print(""); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_or*/ + break; + +/**** + *XOR + */ + case function_xor : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_binary_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_binary_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("("); + if (search_expression_type->is_bool_type(last_type_symbol)) + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("^\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print("^\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + if (search_expression_type->is_bool_type(last_type_symbol)) { + s4o.print("&1"); + s4o.print(")"); + } + s4o.print(""); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_xor*/ + break; + +/**** + *NOT + */ + case function_not : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_binary_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("~"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_not*/ + break; + +/**** + *SEL + */ + case function_sel : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *G_param_value = &this->default_variable_name; + + symbol_c *G_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN0"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN0_param_value == NULL) + IN0_param_value = function_call_param_iterator.next(); + symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; + + + { + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + G_param_value->accept(*this); + s4o.print(" ? "); + IN1_param_value->accept(*this); + s4o.print(" : "); + IN0_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_sel*/ + break; + +/**** + *MAX + */ + case function_max : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("__max_"); + return_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_max*/ + break; + +/**** + *MIN + */ + case function_min : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("__min_"); + return_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_min*/ + break; + +/**** + *LIMIT + */ + case function_limit : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *MN_param_value = &this->default_variable_name; + + symbol_c *MN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + + { + + { + identifier_c param_name("MX"); + /* Get the value from a foo( = ) style call */ + symbol_c *MX_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (MX_param_value == NULL) + MX_param_value = function_call_param_iterator.next(); + symbol_c *MX_type_symbol = search_expression_type->get_type(MX_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(MX_type_symbol, last_type_symbol) ? search_expression_type->common_type(MX_type_symbol, last_type_symbol) : MX_type_symbol ; + + + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("__limit_"); + IN_type_symbol->accept(*this); + s4o.print("("); + MN_param_value->accept(*this); + s4o.print(", "); + IN_param_value->accept(*this); + s4o.print(", "); + MX_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_limit*/ + break; + +/**** + *MUX + */ + case function_mux : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *K_param_value = &this->default_variable_name; + + symbol_c *K_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_integer_type(K_type_symbol)) + { + + { + identifier_c param_name("IN0"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN0_param_value == NULL) + IN0_param_value = function_call_param_iterator.next(); + symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; + + + { + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("__mux_"); + return_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + K_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN0_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + + int base_num = 2; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mux*/ + break; + +/**** + *GT + */ + case function_gt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.indent_right(); + s4o.print("__gt_"); + last_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_gt*/ + break; + +/**** + *GE + */ + case function_ge : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.indent_right(); + s4o.print("__ge_"); + last_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_ge*/ + break; + +/**** + *EQ + */ + case function_eq : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.indent_right(); + s4o.print("__eq_"); + last_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_eq*/ + break; + +/**** + *LT + */ + case function_lt : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.indent_right(); + s4o.print("__lt_"); + last_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_lt*/ + break; + +/**** + *LE + */ + case function_le : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.indent_right(); + s4o.print("__le_"); + last_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_le*/ + break; + +/**** + *NE + */ + case function_ne : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.indent_right(); + s4o.print("__ne_"); + last_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_ne*/ + break; + +/**** + *LEN + */ + case function_len : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("__len("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_len*/ + break; + +/**** + *LEFT + */ + case function_left : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("__left("); + IN_param_value->accept(*this); + s4o.print(", "); + L_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_left*/ + break; + +/**** + *RIGHT + */ + case function_right : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("__right("); + IN_param_value->accept(*this); + s4o.print(", "); + L_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_right*/ + break; + +/**** + *MID + */ + case function_mid : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("__mid("); + IN_param_value->accept(*this); + s4o.print(", "); + L_param_value->accept(*this); + s4o.print(", "); + P_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mid*/ + break; + +/**** + *CONCAT + */ + case function_concat : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("__time_add("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.indent_right(); + s4o.print("__concat("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_concat*/ + break; + +/**** + *INSERT + */ + case function_insert : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("__insert("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(", "); + P_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_insert*/ + break; + +/**** + *DELETE + */ + case function_delete : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = &this->default_variable_name; + + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("__delete("); + IN_param_value->accept(*this); + s4o.print(", "); + L_param_value->accept(*this); + s4o.print(", "); + P_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_delete*/ + break; + +/**** + *REPLACE + */ + case function_replace : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("__replace("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(", "); + L_param_value->accept(*this); + s4o.print(", "); + P_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_replace*/ + break; + +/**** + *FIND + */ + case function_find : + { + symbol_c *last_type_symbol = NULL; + + { + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = &this->default_variable_name; + + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("__find("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_find*/ + break; + + case function_none : + ERROR; +} +return NULL; diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/plc.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/plc.h Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,85 @@ +/* + * (c) 2000 Jiri Baum + * Mario de Sousa + * + * 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. + */ + + +#ifndef __PLC_H +#define __PLC_H + +#include /* required for declaration of FILE */ + +#ifdef __cplusplus +extern "C" { +#endif + + +#include "types.h" +#include "log/log.h" +#include "conffile/conffile.h" +#include "cmm/cmm.h" +#include "gmm/gmm.h" +#include "synch/synch.h" +#include "period/period.h" +#include "state/state.h" +#include "rt/rt.h" + + +#define PLC_PT_NAME_MAX_LEN CMM_NAME_MAX_LEN + +/*** GENERAL ***/ +int plc_init(char const *module_name, int argc, char **argv); +int plc_done(void); + +/*** SYNCHING ***/ +int plc_scan_beg(void); +int plc_scan_end(void); + +/* memory must be de-allocated with free() */ +const char *plc_module_name(void); + +/* + * UTIL functions; + */ +int plc_print_usage(FILE *output); +/* prints the command line arguments the plc_init() function accepts */ + +/* not to be used by general plc modules. This function is used by the + * plc_shutdown() function. + */ +int plc_init_try(char const *module_name, int argc, char **argv); + + +/* plc command line options leader */ +#define CLO_LEADER "--PLC" + +/* plc command line options */ +#define CLO_plc_id CLO_LEADER "plc_id=" +#define CLO_loc_local CLO_LEADER "local" +#define CLO_loc_isolate CLO_LEADER "isolate" +#define CLO_loc_shared CLO_LEADER "shared" +#define CLO_privmap_key CLO_LEADER "local_map_key=" +#define CLO_log_level CLO_LEADER "debug=" +#define CLO_log_file CLO_LEADER "logfile=" +#define CLO_config_file CLO_LEADER "conf=" +#define CLO_module_name CLO_LEADER "module=" +#define CLO_force_init CLO_LEADER "force-init" + + +#ifdef __cplusplus +} +#endif + +#endif /* __PLC_H */ diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/search_base_type.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/search_base_type.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,215 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* Determine the data type on which another data type is based on. + * If a new default initial value is given, we DO NOT consider it a + * new base class, and continue looking further! + * + * E.g. TYPE new_int_t : INT; END_TYPE; + * TYPE new_int2_t : INT = 2; END_TYPE; + * TYPE new_subr_t : INT (4..5); END_TYPE; + * + * new_int_t is really an INT!! + * new_int2_t is also really an INT!! + * new_subr_t is also really an INT!! + */ +class search_base_type_c: public null_visitor_c { + private: + symbol_c *current_type_name; + + public: + search_base_type_c(void) {current_type_name = NULL;} + + public: + void *visit(identifier_c *type_name) { + this->current_type_name = type_name; + /* look up the type declaration... */ + symbol_c *type_decl = type_symtable.find_value(type_name); + if (type_decl == type_symtable.end_value()) + /* Type declaration not found!! */ + ERROR; + + return type_decl->accept(*this); + } + +/***********************************/ +/* B 1.3.1 - Elementary Data Types */ +/***********************************/ + void *visit(time_type_name_c *symbol) {return (void *)symbol;} + void *visit(bool_type_name_c *symbol) {return (void *)symbol;} + void *visit(sint_type_name_c *symbol) {return (void *)symbol;} + void *visit(int_type_name_c *symbol) {return (void *)symbol;} + void *visit(dint_type_name_c *symbol) {return (void *)symbol;} + void *visit(lint_type_name_c *symbol) {return (void *)symbol;} + void *visit(usint_type_name_c *symbol) {return (void *)symbol;} + void *visit(uint_type_name_c *symbol) {return (void *)symbol;} + void *visit(udint_type_name_c *symbol) {return (void *)symbol;} + void *visit(ulint_type_name_c *symbol) {return (void *)symbol;} + void *visit(real_type_name_c *symbol) {return (void *)symbol;} + void *visit(lreal_type_name_c *symbol) {return (void *)symbol;} + void *visit(date_type_name_c *symbol) {return (void *)symbol;} + void *visit(tod_type_name_c *symbol) {return (void *)symbol;} + void *visit(dt_type_name_c *symbol) {return (void *)symbol;} + void *visit(byte_type_name_c *symbol) {return (void *)symbol;} + void *visit(word_type_name_c *symbol) {return (void *)symbol;} + void *visit(dword_type_name_c *symbol) {return (void *)symbol;} + void *visit(lword_type_name_c *symbol) {return (void *)symbol;} + void *visit(string_type_name_c *symbol) {return (void *)symbol;} + void *visit(wstring_type_name_c *symbol) {return (void *)symbol;} + void *visit(constant_int_type_name_c *symbol) {return (void *)symbol;} + void *visit(constant_real_type_name_c *symbol) {return (void *)symbol;} + +/********************************/ +/* B 1.3.3 - Derived data types */ +/********************************/ +/* simple_type_name ':' simple_spec_init */ + void *visit(simple_type_declaration_c *symbol) { + return symbol->simple_spec_init->accept(*this); + } +/* simple_specification ASSIGN constant */ + void *visit(simple_spec_init_c *symbol) { + return symbol->simple_specification->accept(*this); + } + +/* subrange_type_name ':' subrange_spec_init */ + void *visit(subrange_type_declaration_c *symbol) { + return symbol->subrange_spec_init->accept(*this); + } + +/* subrange_specification ASSIGN signed_integer */ + void *visit(subrange_spec_init_c *symbol) { + return symbol->subrange_specification->accept(*this); + } + +/* integer_type_name '(' subrange')' */ + void *visit(subrange_specification_c *symbol) { + return symbol->integer_type_name->accept(*this); + } + +/* signed_integer DOTDOT signed_integer */ + void *visit(subrange_c *symbol) {ERROR; return NULL;} /* should never get called... */ + +/* enumerated_type_name ':' enumerated_spec_init */ + void *visit(enumerated_type_declaration_c *symbol) { + this->current_type_name = symbol->enumerated_type_name; + return symbol->enumerated_spec_init->accept(*this); + } + +/* enumerated_specification ASSIGN enumerated_value */ + void *visit(enumerated_spec_init_c *symbol) { + return symbol->enumerated_specification->accept(*this); + } + +/* helper symbol for enumerated_specification->enumerated_spec_init */ +/* enumerated_value_list ',' enumerated_value */ + void *visit(enumerated_value_list_c *symbol) { + if (NULL == this->current_type_name) ERROR; + return (void *)this->current_type_name; + } + +/* enumerated_type_name '#' identifier */ +// SYM_REF2(enumerated_value_c, type, value) + void *visit(enumerated_value_c *symbol) {ERROR; return NULL;} /* should never get called... */ + +/* identifier ':' array_spec_init */ + void *visit(array_type_declaration_c *symbol) { + this->current_type_name = symbol->identifier; + return symbol->array_spec_init->accept(*this); + } + +/* array_specification [ASSIGN array_initialization} */ +/* array_initialization may be NULL ! */ + void *visit(array_spec_init_c *symbol) { + return symbol->array_specification->accept(*this); + } + +/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */ + void *visit(array_specification_c *symbol) { + if (NULL == this->current_type_name) ERROR; + return (void *)this->current_type_name; + } + +/* helper symbol for array_specification */ +/* array_subrange_list ',' subrange */ + void *visit(array_subrange_list_c *symbol) {ERROR; return NULL;} /* should never get called... */ + +/* array_initialization: '[' array_initial_elements_list ']' */ +/* helper symbol for array_initialization */ +/* array_initial_elements_list ',' array_initial_elements */ + void *visit(array_initial_elements_list_c *symbol) {ERROR; return NULL;} /* should never get called... */ + +/* integer '(' [array_initial_element] ')' */ +/* array_initial_element may be NULL ! */ + void *visit(array_initial_elements_c *symbol) {ERROR; return NULL;} /* should never get called... */ + +/* structure_type_name ':' structure_specification */ + /* NOTE: structure_specification will point to either a + * initialized_structure_c + * OR A + * structure_element_declaration_list_c + */ + void *visit(structure_type_declaration_c *symbol) { + this->current_type_name = symbol->structure_type_name; + return symbol->structure_specification->accept(*this); + } + +/* structure_type_name ASSIGN structure_initialization */ +/* structure_initialization may be NULL ! */ + void *visit(initialized_structure_c *symbol) { + return symbol->structure_type_name->accept(*this); + } + +/* helper symbol for structure_declaration */ +/* structure_declaration: STRUCT structure_element_declaration_list END_STRUCT */ +/* structure_element_declaration_list structure_element_declaration ';' */ + void *visit(structure_element_declaration_list_c *symbol) { + if (NULL == this->current_type_name) ERROR; + return (void *)this->current_type_name; + } + +/* structure_element_name ':' *_spec_init */ + void *visit(structure_element_declaration_c *symbol) {ERROR; return NULL;} /* should never get called... */ + +/* helper symbol for structure_initialization */ +/* structure_initialization: '(' structure_element_initialization_list ')' */ +/* structure_element_initialization_list ',' structure_element_initialization */ + void *visit(structure_element_initialization_list_c *symbol) {ERROR; return NULL;} /* should never get called... */ + +/* structure_element_name ASSIGN value */ + void *visit(structure_element_initialization_c *symbol) {ERROR; return NULL;} /* should never get called... */ + +/* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ +/* +SYM_REF4(string_type_declaration_c, string_type_name, + elementary_string_type_name, + string_type_declaration_size, + string_type_declaration_init) // may be == NULL! +*/ + void *visit(string_type_declaration_c *symbol) {return symbol;} +}; + + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/search_constant_type.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/search_constant_type.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,161 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + + +/* Determine the data type of a specific constant or variable. + * A reference to the relevant type definition is returned. + * + * For example: + * 22 -> returns reference to a int_type_name_c object. + * 22.2 -> returns reference to a real_type_name_c object. + * LREAL#22.2 -> returns reference to a lreal_type_name_c object. + * etc... + */ +class search_constant_type_c: public search_visitor_c { + + public: +/**********************/ +/* B.1.3 - Data types */ +/**********************/ +/***********************************/ +/* B 1.3.1 - Elementary Data Types */ +/***********************************/ + static real_type_name_c real_type_name; + static sint_type_name_c sint_type_name; + static lint_type_name_c lint_type_name; + static dint_type_name_c dint_type_name; + static date_type_name_c date_type_name; + static dword_type_name_c dword_type_name; + static dt_type_name_c dt_type_name; + static tod_type_name_c tod_type_name; + static udint_type_name_c udint_type_name; + static word_type_name_c word_type_name; + static wstring_type_name_c wstring_type_name; + static string_type_name_c string_type_name; + static lword_type_name_c lword_type_name; + static uint_type_name_c uint_type_name; + static lreal_type_name_c lreal_type_name; + static byte_type_name_c byte_type_name; + static usint_type_name_c usint_type_name; + static ulint_type_name_c ulint_type_name; + static bool_type_name_c bool_type_name; + static time_type_name_c time_type_name; + static int_type_name_c int_type_name; + + static constant_real_type_name_c constant_real_type_name; + static constant_int_type_name_c constant_int_type_name; + + public: + symbol_c *get_type(symbol_c *constant) { + return (symbol_c *)constant->accept(*this); + } + + public: +/*********************/ +/* B 1.2 - Constants */ +/*********************/ + +/******************************/ +/* B 1.2.1 - Numeric Literals */ +/******************************/ + void *visit(real_c *symbol) {return (void *)&constant_real_type_name;} + void *visit(integer_c *symbol) {return (void *)&constant_int_type_name;} + void *visit(binary_integer_c *symbol) {return (void *)&constant_int_type_name;} + void *visit(octal_integer_c *symbol) {return (void *)&constant_int_type_name;} + void *visit(hex_integer_c *symbol) {return (void *)&constant_int_type_name;} + + void *visit(numeric_literal_c *symbol) + {return (void *)((symbol->type!=NULL)?symbol->type:symbol->value->accept(*this));} + void *visit(integer_literal_c *symbol) + {return (void *)((symbol->type!=NULL)?symbol->type:symbol->value->accept(*this));} + void *visit(real_literal_c *symbol) + {return (void *)((symbol->type!=NULL)?symbol->type:symbol->value->accept(*this));} + void *visit(bit_string_literal_c *symbol) + {return (void *)((symbol->type!=NULL)?symbol->type:symbol->value->accept(*this));} + void *visit(boolean_literal_c *symbol) + {return (void *)((symbol->type!=NULL)?symbol->type:symbol->value->accept(*this));} + +/*******************************/ +/* B.1.2.2 Character Strings */ +/*******************************/ + void *visit(double_byte_character_string_c *symbol) {return (void *)&wstring_type_name;} + void *visit(single_byte_character_string_c *symbol) {return (void *)&string_type_name;} + +/***************************/ +/* B 1.2.3 - Time Literals */ +/***************************/ +/************************/ +/* B 1.2.3.1 - Duration */ +/************************/ + void *visit(neg_time_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ + void *visit(duration_c *symbol) {return (void *)&time_type_name;} + void *visit(fixed_point_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ + void *visit(days_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ + void *visit(hours_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ + void *visit(minutes_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ + void *visit(seconds_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ + void *visit(milliseconds_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ + +/************************************/ +/* B 1.2.3.2 - Time of day and Date */ +/************************************/ + void *visit(time_of_day_c *symbol) {return (void *)&tod_type_name;} + void *visit(daytime_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ + void *visit(date_c *symbol) {return (void *)&date_type_name;} + void *visit(date_literal_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ + void *visit(date_and_time_c *symbol) {return (void *)&dt_type_name;} +}; + + +real_type_name_c search_constant_type_c::real_type_name; +sint_type_name_c search_constant_type_c::sint_type_name; +lint_type_name_c search_constant_type_c::lint_type_name; +dint_type_name_c search_constant_type_c::dint_type_name; +date_type_name_c search_constant_type_c::date_type_name; +dword_type_name_c search_constant_type_c::dword_type_name; +dt_type_name_c search_constant_type_c::dt_type_name; +tod_type_name_c search_constant_type_c::tod_type_name; +udint_type_name_c search_constant_type_c::udint_type_name; +word_type_name_c search_constant_type_c::word_type_name; +wstring_type_name_c search_constant_type_c::wstring_type_name; +string_type_name_c search_constant_type_c::string_type_name; +lword_type_name_c search_constant_type_c::lword_type_name; +uint_type_name_c search_constant_type_c::uint_type_name; +lreal_type_name_c search_constant_type_c::lreal_type_name; +byte_type_name_c search_constant_type_c::byte_type_name; +usint_type_name_c search_constant_type_c::usint_type_name; +ulint_type_name_c search_constant_type_c::ulint_type_name; +bool_type_name_c search_constant_type_c::bool_type_name; +time_type_name_c search_constant_type_c::time_type_name; +int_type_name_c search_constant_type_c::int_type_name; + +constant_real_type_name_c search_constant_type_c::constant_real_type_name; +constant_int_type_name_c search_constant_type_c::constant_int_type_name; + + + + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/search_expression_type.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/search_expression_type.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,494 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* Determine the data type of an ST expression. + * A reference to the relevant type definition is returned. + * + * For example: + * 2 + 3 -> returns reference to a int_type_name_c object. + * 22.2 - 5 -> returns reference to a real_type_name_c object. + * etc... + */ + +#include "function_type_decl.h" +#include "get_function_type_decl.c" + +#if 0 +typedef enum {function_add, + function_sub, + function_and, + function_or, + function_sqrt, + function_none} function_type_t; + + +function_type_t get_function_type(identifier_c *function_name) { + if (!strcasecmp(function_name->value, "ADD")) + return function_add; + else if (!strcasecmp(function_name->value, "SUB")) + return function_sub; + else if (!strcasecmp(function_name->value, "AND")) + return function_and; + else if (!strcasecmp(function_name->value, "OR")) + return function_or; + else if (!strcasecmp(function_name->value, "SQRT")) + return function_sqrt; + else return function_none; +} +#endif + + +symbol_c *generate_param_name(const char *name) { + symbol_c *param_name = new identifier_c(name); + return param_name; +} + + +symbol_c *generate_param_name(const char *format, int number) { + char name[10]; + sprintf(name, format, number); + symbol_c *param_name = new identifier_c(name); + return param_name; +} + + +class search_expression_type_c: public search_constant_type_c { + private: + search_varfb_instance_type_c *search_varfb_instance_type; + search_base_type_c search_base_type; + + public: + search_expression_type_c(symbol_c *search_scope) { + search_varfb_instance_type = new search_varfb_instance_type_c(search_scope); + } + + virtual ~search_expression_type_c(void) { + delete search_varfb_instance_type; + } + + /* A helper function... */ + bool is_bool_type(symbol_c *type_symbol) { + return (typeid(*type_symbol) == typeid(bool_type_name_c)); + } + + /* A helper function... */ + bool is_time_type(symbol_c *type_symbol) { + if (typeid(*type_symbol) == typeid(time_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(date_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(tod_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(dt_type_name_c)) {return true;} + return false; + } + + /* A helper function... */ + bool is_integer_type(symbol_c *type_symbol) { + if (typeid(*type_symbol) == typeid(sint_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(int_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(dint_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(lint_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(usint_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(uint_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(udint_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(ulint_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(constant_int_type_name_c)) {return true;} + return false; + } + + bool is_real_type(symbol_c *type_symbol) { + if (typeid(*type_symbol) == typeid(real_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(lreal_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(constant_real_type_name_c)) {return true;} + return false; + } + + bool is_num_type(symbol_c *type_symbol) { + return is_real_type(type_symbol) || is_integer_type(type_symbol); + } + + bool is_nbinary_type(symbol_c *type_symbol) { + if (typeid(*type_symbol) == typeid(byte_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(word_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(dword_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(lword_type_name_c)) {return true;} + if (typeid(*type_symbol) == typeid(constant_int_type_name_c)) {return true;} + return false; + } + + bool is_binary_type(symbol_c *type_symbol) { + if (typeid(*type_symbol) == typeid(bool_type_name_c)) {return true;} + return is_nbinary_type(type_symbol); + } + + bool is_same_type(symbol_c *first_type, symbol_c *second_type) { + if (typeid(*first_type) == typeid(*second_type)) {return true;} + if (is_integer_type(first_type) && (typeid(*second_type) == typeid(constant_int_type_name_c))) {return true;} + if ((typeid(*first_type) == typeid(constant_int_type_name_c) && is_integer_type(second_type))) {return true;} + if (is_binary_type(first_type) && (typeid(*second_type) == typeid(constant_int_type_name_c))) {return true;} + if ((typeid(*first_type) == typeid(constant_int_type_name_c) && is_binary_type(second_type))) {return true;} + if (is_real_type(first_type) && (typeid(*second_type) == typeid(constant_real_type_name_c))) {return true;} + if ((typeid(*first_type) == typeid(constant_real_type_name_c) && is_real_type(second_type))) {return true;} + return false; + } + + symbol_c* common_type(symbol_c *first_type, symbol_c *second_type) { + if (typeid(*first_type) == typeid(*second_type)) {return first_type;} + if (is_integer_type(first_type) && (typeid(*second_type) == typeid(constant_int_type_name_c))) {return first_type;} + if ((typeid(*first_type) == typeid(constant_int_type_name_c) && is_integer_type(second_type))) {return second_type;} + if (is_binary_type(first_type) && (typeid(*second_type) == typeid(constant_int_type_name_c))) {return first_type;} + if ((typeid(*first_type) == typeid(constant_int_type_name_c) && is_binary_type(second_type))) {return second_type;} + if (is_real_type(first_type) && (typeid(*second_type) == typeid(constant_real_type_name_c))) {return first_type;} + if ((typeid(*first_type) == typeid(constant_real_type_name_c) && is_real_type(second_type))) {return second_type;} + return NULL; + } + +#include "search_type_code.c" + +#if 0 + void *compute_standard_function_st(function_invocation_c *symbol) { + symbol_c *current_type = NULL; + symbol_c *return_type = NULL; + + function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name); + function_call_param_iterator_c function_call_param_iterator(symbol); + search_expression_type_c* search_expression_type = this; + + for(int current_param = 0; current_param < ((list_c *)symbol->parameter_assignment_list)->n; current_param++) { + symbol_c *param_name = NULL; + switch (current_function_type) { + case function_add: + case function_and: + case function_or: + param_name = generate_param_name("IN%d", current_param + 1); + break; + case function_sub: + if (current_param < 2) + param_name = generate_param_name("IN%d", current_param + 1); + else ERROR; + break; + default: ERROR; + } + + /* Get the value from a foo( = ) style call */ + symbol_c *param_value = function_call_param_iterator.search(param_name); + delete param_name; + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + + if (param_value == NULL) ERROR; + + symbol_c *param_type = (symbol_c *)param_value->accept(*this); + + switch (current_function_type) { + case function_add: + if (current_param == 0) + current_type = param_type; + else if (current_param == 1) { + if ((is_integer_type(current_type) && is_same_type(current_type, param_type)) || + (is_real_type(current_type) && is_same_type(current_type, param_type))) { + current_type = common_type(current_type, param_type); + return_type = current_type; + } + else if (is_time_type(current_type)) { + if ((typeid(*current_type) == typeid(time_type_name_c)) && (typeid(*param_type) == typeid(time_type_name_c))) {return_type = (symbol_c *)&time_type_name;} + else if (typeid(*current_type) == typeid(tod_type_name_c) && typeid(*param_type) == typeid(time_type_name_c)) {return_type = (symbol_c *)&tod_type_name;} + else if (typeid(*current_type) == typeid(dt_type_name_c) && typeid(*param_type) == typeid(time_type_name_c)) {return_type = (symbol_c *)&dt_type_name;} + else ERROR; + } + else ERROR; + } + else if (!is_time_type(current_type) && is_same_type(current_type, param_type)) { + current_type = common_type(current_type, param_type); + return_type = current_type; + } + else ERROR; + break; + case function_sub: + if (current_param == 0) + current_type = param_type; + else if (current_param == 1) { + if ((is_integer_type(current_type) && is_same_type(current_type, param_type)) || + (is_real_type(current_type) && is_same_type(current_type, param_type))) + return_type = common_type(current_type, param_type); + else if (is_time_type(current_type)) { + if (typeid(*current_type) == typeid(time_type_name_c) && typeid(*param_type) == typeid(time_type_name_c)) {return_type = (symbol_c *)&time_type_name;} + else if (typeid(*current_type) == typeid(date_type_name_c) && typeid(*param_type) == typeid(date_type_name_c)) {return_type = (symbol_c *)&time_type_name;} + else if (typeid(*current_type) == typeid(tod_type_name_c) && typeid(*param_type) == typeid(time_type_name_c)) {return_type = (symbol_c *)&tod_type_name;} + else if (typeid(*current_type) == typeid(tod_type_name_c) && typeid(*param_type) == typeid(tod_type_name_c)) {return_type = (symbol_c *)&time_type_name;} + else if (typeid(*current_type) == typeid(dt_type_name_c) && typeid(*param_type) == typeid(time_type_name_c)) {return_type = (symbol_c *)&dt_type_name;} + else if (typeid(*current_type) == typeid(dt_type_name_c) && typeid(*param_type) == typeid(dt_type_name_c)) {return_type = (symbol_c *)&time_type_name;} + else ERROR; + } + else ERROR; + } + else ERROR; + break; + case function_and: + case function_or: + if (current_param == 0) + if (is_binary_type(param_type)) + current_type = param_type; + else ERROR; + else if (is_same_type(current_type, param_type)) + return_type = common_type(current_type, param_type); + else ERROR; + break; + default: ERROR; + } + } + return (void *)return_type; + } + + void *compute_standard_function_il(il_function_call_c *symbol, symbol_c *param_type) { + /*symbol_c *current_type = NULL;*/ + symbol_c *return_type = NULL; + function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name); + if (current_function_type == function_none) ERROR; + + function_call_param_iterator_c function_call_param_iterator(symbol); + + int nb_param = 1; + if (symbol->il_operand_list != NULL) + nb_param += ((list_c *)symbol->il_operand_list)->n; + + for(int current_param = 0; current_param < nb_param; current_param++) { + + if (current_param != 0) { + symbol_c *param_name = NULL; + switch (current_function_type) { + default: ERROR; + } + + /* Get the value from a foo( = ) style call */ + symbol_c *param_value = function_call_param_iterator.search(param_name); + delete param_name; + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + + if (param_value == NULL) ERROR; + + param_type = (symbol_c *)param_value->accept(*this); + } + + switch (current_function_type) { + case function_sqrt: + if (current_param == 0 && is_real_type(param_type)) + return_type = param_type; + else ERROR; + break; + default: ERROR; + } + } + + return (void *)return_type; + } +#endif + + /*static bool_type_name_c bool_type_name;*/ + + /* A helper function... */ + void *compute_boolean_expression(symbol_c *left_type, symbol_c *right_type) { + if (!is_same_type(left_type, right_type)) + ERROR; + if (!is_bool_type(left_type) && !is_binary_type(left_type)) + ERROR; + if (typeid(*left_type) == typeid(constant_int_type_name_c)) {return (void *)right_type;} + else {return (void *)left_type;} + } + + /* A helper function... */ + void *compute_numeric_expression(symbol_c *left_type, symbol_c *right_type) { + if (!is_same_type(left_type, right_type)) + ERROR; + if (!is_integer_type(left_type) && !is_real_type(left_type)) + ERROR; + if ((typeid(*left_type) == typeid(constant_int_type_name_c)) || (typeid(*left_type) == typeid(constant_real_type_name_c))) {return (void *)right_type;} + else {return (void *)left_type;} + return NULL; + } + + /* a helper function... */ + symbol_c *base_type(symbol_c *symbol) { + return (symbol_c *)symbol->accept(search_base_type); + } + +/*********************/ +/* B 1.4 - Variables */ +/*********************/ + + void *visit(symbolic_variable_c *symbol) { + symbol_c *res; + + /* Nope, now we assume it is a variable, and determine its type... */ + res = search_varfb_instance_type->get_type(symbol); + if (NULL != res) return res; + + return NULL; + } + +/*************************************/ +/* B 1.4.2 - Multi-element variables */ +/*************************************/ + + void *visit(array_variable_c *symbol) { + symbol_c *res; + + /* Nope, now we assume it is a variable, and determine its type... */ + res = search_varfb_instance_type->get_type(symbol); + if (NULL != res) return res; + + return NULL; + } + + void *visit(structured_variable_c *symbol) { + symbol_c *res; + + /* Nope, now we assume it is a variable, and determine its type... */ + res = search_varfb_instance_type->get_type(symbol); + if (NULL != res) return res; + + return NULL; + } + +/***************************************/ +/* B.3 - Language ST (Structured Text) */ +/***************************************/ +/***********************/ +/* B 3.1 - Expressions */ +/***********************/ + void *visit(or_expression_c *symbol) { + symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); + symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); + return compute_boolean_expression(left_type, right_type); + } + + void *visit(xor_expression_c *symbol) { + symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); + symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); + return compute_boolean_expression(left_type, right_type); + } + + void *visit(and_expression_c *symbol) { + symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); + symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); + return compute_boolean_expression(left_type, right_type); + } + + void *visit(equ_expression_c *symbol) {return (void *)&bool_type_name;} + void *visit(notequ_expression_c *symbol) {return (void *)&bool_type_name;} + void *visit(lt_expression_c *symbol) {return (void *)&bool_type_name;} + void *visit(gt_expression_c *symbol) {return (void *)&bool_type_name;} + void *visit(le_expression_c *symbol) {return (void *)&bool_type_name;} + void *visit(ge_expression_c *symbol) {return (void *)&bool_type_name;} + + void *visit(add_expression_c *symbol) { + symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); + symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); + if (typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) {return (void *)&time_type_name;} + if (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) {return (void *)&tod_type_name;} + if (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) {return (void *)&dt_type_name;} + return compute_numeric_expression(left_type, right_type); + } + + void *visit(sub_expression_c *symbol) { + symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); + symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); + if (typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) {return (void *)&time_type_name;} + if (typeid(*left_type) == typeid(date_type_name_c) && typeid(*right_type) == typeid(date_type_name_c)) {return (void *)&time_type_name;} + if (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) {return (void *)&tod_type_name;} + if (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(tod_type_name_c)) {return (void *)&time_type_name;} + if (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) {return (void *)&dt_type_name;} + if (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(dt_type_name_c)) {return (void *)&time_type_name;} + return compute_numeric_expression(left_type, right_type); + } + + void *visit(mul_expression_c *symbol) { + symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); + symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); + if (typeid(*left_type) == typeid(time_type_name_c) && is_num_type(right_type)) { + return (void *)&time_type_name; + } + return compute_numeric_expression(left_type, right_type); + } + + void *visit(div_expression_c *symbol) { + symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); + symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); + if (typeid(*left_type) == typeid(time_type_name_c) && is_num_type(right_type)){ + return (void *)&time_type_name; + } + return compute_numeric_expression(left_type, right_type); + } + + void *visit(mod_expression_c *symbol) { + symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); + symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); + return compute_numeric_expression(left_type, right_type); + } + + void *visit(power_expression_c *symbol) { + symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); + symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); + if (is_real_type(left_type) && is_num_type(right_type)) { + return (void *)left_type; + } + ERROR; + return NULL; + } + + void *visit(neg_expression_c *symbol) { + symbol_c *exp_type = base_type((symbol_c *)symbol->exp->accept(*this)); + if (is_num_type(exp_type) || typeid(*exp_type) == typeid(time_type_name_c)){ + return (void *)exp_type; + } + ERROR; + return NULL; + } + + void *visit(not_expression_c *symbol) { + symbol_c *exp_type = base_type((symbol_c *)symbol->exp->accept(*this)); + return compute_boolean_expression(exp_type, exp_type); + } + + void *visit(function_invocation_c *symbol) { + function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name); + + if (f_decl == function_symtable.end_value()) { + void *res = compute_standard_function_st(symbol); + if (res == NULL) + ERROR; + return res; + } + + return base_type(f_decl->type_name); + } + +}; + +/*bool_type_name_c search_expression_type_c::bool_type_name;*/ + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/search_fb_instance_decl.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/search_fb_instance_decl.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,141 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* Returns the function block type declaration + * of a specific function block instance. + */ + + + +/* Returns the type name of a specific function block + * instance. This class will search the variable + * declarations inside the scope given to it + * searching for the declaration of the function + * block instance. + * + * The class constructor must be given the search scope + * (function, function block or program within which + * the function block instance was declared). + * + * This class will search the tree from the root given to the + * constructor. Another option would be to build a symbol table, + * and search that instead. Building the symbol table would be done + * while visiting the variable declaration objects in the parse + * tree. Unfortuantely, generate_c_c does not visit these + * objects, delegating it to another class. This means that + * we would need another specialised class just to build the + * symbol table. We might just as well have a specialised class + * that searches the tree itself for the relevant info. This + * class is exactly that...! + */ +class search_fb_instance_decl_c: public search_visitor_c { + + private: + symbol_c *search_scope; + + symbol_c *search_name; + symbol_c *current_fb_type_name; + + public: + search_fb_instance_decl_c(symbol_c *search_scope) { + this->search_scope = search_scope; + this->current_fb_type_name = NULL; + } + + symbol_c *get_type_name(symbol_c *fb_instance_name) { + this->search_name = fb_instance_name; + return (symbol_c *)search_scope->accept(*this); + } + + public: +/***************************/ +/* B 0 - Programming Model */ +/***************************/ + void *visit(library_c *symbol) { + /* we do not want to search multiple declaration scopes, + * so we do not visit all the functions, fucntion blocks, etc... + */ + return NULL; + } + +/******************************************/ +/* B 1.4.3 - Declaration & Initialisation */ +/******************************************/ + +/* name_list ':' function_block_type_name ASSIGN structure_initialization */ +/* structure_initialization -> may be NULL ! */ + void *visit(fb_name_decl_c *symbol) { + current_fb_type_name = symbol->function_block_type_name; + return symbol->fb_name_list->accept(*this); + } + +/* name_list ',' fb_name */ + void *visit(fb_name_list_c *symbol) { + list_c *list = symbol; + for(int i = 0; i < list->n; i++) { + if (compare_identifiers(list->elements[i], search_name) == 0) + /* by now, current_fb_declaration should be != NULL */ + return current_fb_type_name; + } + return NULL; + } + +/**************************************/ +/* B.1.5 - Program organization units */ +/**************************************/ +/***********************/ +/* B 1.5.1 - Functions */ +/***********************/ + void *visit(function_declaration_c *symbol) { + /* no need to search through all the body, so we only + * visit the variable declarations...! + */ + return symbol->var_declarations_list->accept(*this); + } + +/*****************************/ +/* B 1.5.2 - Function Blocks */ +/*****************************/ + void *visit(function_block_declaration_c *symbol) { + /* no need to search through all the body, so we only + * visit the variable declarations...! + */ + return symbol->var_declarations->accept(*this); + } + +/**********************/ +/* B 1.5.3 - Programs */ +/**********************/ + void *visit(program_declaration_c *symbol) { + /* no need to search through all the body, so we only + * visit the variable declarations...! + */ + return symbol->var_declarations->accept(*this); + } +}; + + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/search_type_code.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/search_type_code.c Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,26146 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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 lib + * generated code, do not edit by hand + */ + +void *compute_standard_function_st(function_invocation_c *symbol) { + + function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name); + function_call_param_iterator_c function_call_param_iterator(symbol); + search_expression_type_c* search_expression_type = this; + + switch(current_function_type){ + +/**** + *BOOL_TO_SINT + */ + case function_bool_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_sint*/ + break; + +/**** + *BOOL_TO_INT + */ + case function_bool_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_int*/ + break; + +/**** + *BOOL_TO_DINT + */ + case function_bool_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_dint*/ + break; + +/**** + *BOOL_TO_LINT + */ + case function_bool_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_lint*/ + break; + +/**** + *BOOL_TO_USINT + */ + case function_bool_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_usint*/ + break; + +/**** + *BOOL_TO_UINT + */ + case function_bool_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_uint*/ + break; + +/**** + *BOOL_TO_UDINT + */ + case function_bool_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_udint*/ + break; + +/**** + *BOOL_TO_ULINT + */ + case function_bool_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_ulint*/ + break; + +/**** + *BOOL_TO_REAL + */ + case function_bool_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_real*/ + break; + +/**** + *BOOL_TO_LREAL + */ + case function_bool_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_lreal*/ + break; + +/**** + *BOOL_TO_TIME + */ + case function_bool_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_time*/ + break; + +/**** + *BOOL_TO_DATE + */ + case function_bool_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_date*/ + break; + +/**** + *BOOL_TO_TOD + */ + case function_bool_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_tod*/ + break; + +/**** + *BOOL_TO_DT + */ + case function_bool_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_dt*/ + break; + +/**** + *BOOL_TO_STRING + */ + case function_bool_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_string*/ + break; + +/**** + *BOOL_TO_BYTE + */ + case function_bool_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_byte*/ + break; + +/**** + *BOOL_TO_WORD + */ + case function_bool_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_word*/ + break; + +/**** + *BOOL_TO_DWORD + */ + case function_bool_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_dword*/ + break; + +/**** + *BOOL_TO_LWORD + */ + case function_bool_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_lword*/ + break; + +/**** + *INT_TO_BOOL + */ + case function_int_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_bool*/ + break; + +/**** + *INT_TO_SINT + */ + case function_int_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_sint*/ + break; + +/**** + *INT_TO_DINT + */ + case function_int_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_dint*/ + break; + +/**** + *INT_TO_LINT + */ + case function_int_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_lint*/ + break; + +/**** + *INT_TO_USINT + */ + case function_int_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_usint*/ + break; + +/**** + *INT_TO_UINT + */ + case function_int_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_uint*/ + break; + +/**** + *INT_TO_UDINT + */ + case function_int_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_udint*/ + break; + +/**** + *INT_TO_ULINT + */ + case function_int_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_ulint*/ + break; + +/**** + *INT_TO_REAL + */ + case function_int_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_real*/ + break; + +/**** + *INT_TO_LREAL + */ + case function_int_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_lreal*/ + break; + +/**** + *INT_TO_TIME + */ + case function_int_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_time*/ + break; + +/**** + *INT_TO_DATE + */ + case function_int_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_date*/ + break; + +/**** + *INT_TO_TOD + */ + case function_int_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_tod*/ + break; + +/**** + *INT_TO_DT + */ + case function_int_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_dt*/ + break; + +/**** + *INT_TO_STRING + */ + case function_int_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_string*/ + break; + +/**** + *INT_TO_BYTE + */ + case function_int_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_byte*/ + break; + +/**** + *INT_TO_WORD + */ + case function_int_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_word*/ + break; + +/**** + *INT_TO_DWORD + */ + case function_int_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_dword*/ + break; + +/**** + *INT_TO_LWORD + */ + case function_int_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_lword*/ + break; + +/**** + *USINT_TO_BOOL + */ + case function_usint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_sint*/ + break; + +/**** + *USINT_TO_INT + */ + case function_usint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_lreal*/ + break; + +/**** + *USINT_TO_TIME + */ + case function_usint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_lword*/ + break; + +/**** + *ULINT_TO_BOOL + */ + case function_ulint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_bool*/ + break; + +/**** + *ULINT_TO_SINT + */ + case function_ulint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_sint*/ + break; + +/**** + *ULINT_TO_INT + */ + case function_ulint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_int*/ + break; + +/**** + *ULINT_TO_DINT + */ + case function_ulint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_dint*/ + break; + +/**** + *ULINT_TO_LINT + */ + case function_ulint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_lint*/ + break; + +/**** + *ULINT_TO_USINT + */ + case function_ulint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_usint*/ + break; + +/**** + *ULINT_TO_UINT + */ + case function_ulint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_uint*/ + break; + +/**** + *ULINT_TO_UDINT + */ + case function_ulint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_udint*/ + break; + +/**** + *ULINT_TO_REAL + */ + case function_ulint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_real*/ + break; + +/**** + *ULINT_TO_LREAL + */ + case function_ulint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_lreal*/ + break; + +/**** + *ULINT_TO_TIME + */ + case function_ulint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_time*/ + break; + +/**** + *ULINT_TO_DATE + */ + case function_ulint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_date*/ + break; + +/**** + *ULINT_TO_TOD + */ + case function_ulint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_tod*/ + break; + +/**** + *ULINT_TO_DT + */ + case function_ulint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_dt*/ + break; + +/**** + *ULINT_TO_STRING + */ + case function_ulint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_string*/ + break; + +/**** + *ULINT_TO_BYTE + */ + case function_ulint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_byte*/ + break; + +/**** + *ULINT_TO_WORD + */ + case function_ulint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_word*/ + break; + +/**** + *ULINT_TO_DWORD + */ + case function_ulint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_dword*/ + break; + +/**** + *ULINT_TO_LWORD + */ + case function_ulint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_bool*/ + break; + +/**** + *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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_lword*/ + break; + +/**** + *TIME_TO_SINT + */ + case function_time_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_sint*/ + break; + +/**** + *TIME_TO_INT + */ + case function_time_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_int*/ + break; + +/**** + *TIME_TO_DINT + */ + case function_time_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_dint*/ + break; + +/**** + *TIME_TO_LINT + */ + case function_time_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_lint*/ + break; + +/**** + *TIME_TO_USINT + */ + case function_time_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_usint*/ + break; + +/**** + *TIME_TO_UINT + */ + case function_time_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_uint*/ + break; + +/**** + *TIME_TO_UDINT + */ + case function_time_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_udint*/ + break; + +/**** + *TIME_TO_ULINT + */ + case function_time_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_ulint*/ + break; + +/**** + *TIME_TO_REAL + */ + case function_time_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_real*/ + break; + +/**** + *TIME_TO_LREAL + */ + case function_time_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_lreal*/ + break; + +/**** + *TIME_TO_STRING + */ + case function_time_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_string*/ + break; + +/**** + *TIME_TO_BYTE + */ + case function_time_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_byte*/ + break; + +/**** + *TIME_TO_WORD + */ + case function_time_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_word*/ + break; + +/**** + *TIME_TO_DWORD + */ + case function_time_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_dword*/ + break; + +/**** + *TIME_TO_LWORD + */ + case function_time_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_dword*/ + break; + +/**** + *TRUNC + */ + case function_trunc : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_trunc*/ + break; + +/**** + *BCD_TO_USINT + */ + case function_bcd_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bcd_to_usint*/ + break; + +/**** + *BCD_TO_UINT + */ + case function_bcd_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bcd_to_uint*/ + break; + +/**** + *BCD_TO_UDINT + */ + case function_bcd_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bcd_to_udint*/ + break; + +/**** + *BCD_TO_ULINT + */ + case function_bcd_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bcd_to_ulint*/ + break; + +/**** + *USINT_TO_BCD + */ + case function_usint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_bcd*/ + break; + +/**** + *UINT_TO_BCD + */ + case function_uint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_bcd*/ + break; + +/**** + *UDINT_TO_BCD + */ + case function_udint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_bcd*/ + break; + +/**** + *ULINT_TO_BCD + */ + case function_ulint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_bcd*/ + break; + +/**** + *DATE_AND_TIME_TO_TIME_OF_DAY + */ + case function_date_and_time_to_time_of_day : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_and_time_to_time_of_day*/ + break; + +/**** + *DATE_AND_TIME_TO_DATE + */ + case function_date_and_time_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_and_time_to_date*/ + break; + +/**** + *ABS + */ + case function_abs : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_num_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_abs*/ + break; + +/**** + *SQRT + */ + case function_sqrt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sqrt*/ + break; + +/**** + *LN + */ + case function_ln : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ln*/ + break; + +/**** + *LOG + */ + case function_log : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_log*/ + break; + +/**** + *EXP + */ + case function_exp : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_exp*/ + break; + +/**** + *SIN + */ + case function_sin : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sin*/ + break; + +/**** + *COS + */ + case function_cos : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_cos*/ + break; + +/**** + *TAN + */ + case function_tan : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tan*/ + break; + +/**** + *ASIN + */ + case function_asin : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_asin*/ + break; + +/**** + *ACOS + */ + case function_acos : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_acos*/ + break; + +/**** + *ATAN + */ + case function_atan : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_atan*/ + break; + +/**** + *ADD + */ + case function_add : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_add*/ + break; + +/**** + *MUL + */ + case function_mul : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mul*/ + break; + +/**** + *SUB + */ + case function_sub : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_sub*/ + break; + +/**** + *DIV + */ + case function_div : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_div*/ + break; + +/**** + *MOD + */ + case function_mod : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mod*/ + break; + +/**** + *EXPT + */ + case function_expt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_expt*/ + break; + +/**** + *MOVE + */ + case function_move : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_num_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_move*/ + break; + +/**** + *SHL + */ + case function_shl : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_binary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_shl*/ + break; + +/**** + *SHR + */ + case function_shr : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_binary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_shr*/ + break; + +/**** + *ROR + */ + case function_ror : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_nbinary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_ror*/ + break; + +/**** + *ROL + */ + case function_rol : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_nbinary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_rol*/ + break; + +/**** + *AND + */ + case function_and : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_binary_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_binary_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_and*/ + break; + +/**** + *OR + */ + case function_or : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_binary_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_binary_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_or*/ + break; + +/**** + *XOR + */ + case function_xor : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_binary_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_binary_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_xor*/ + break; + +/**** + *NOT + */ + case function_not : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_binary_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_not*/ + break; + +/**** + *SEL + */ + case function_sel : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("G"); + /* Get the value from a foo( = ) style call */ + symbol_c *G_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (G_param_value == NULL) + G_param_value = function_call_param_iterator.next(); + symbol_c *G_type_symbol = search_expression_type->get_type(G_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(G_type_symbol, last_type_symbol) ? search_expression_type->common_type(G_type_symbol, last_type_symbol) : G_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN0"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN0_param_value == NULL) + IN0_param_value = function_call_param_iterator.next(); + symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; + + + { + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_sel*/ + break; + +/**** + *MAX + */ + case function_max : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_max*/ + break; + +/**** + *MIN + */ + case function_min : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_min*/ + break; + +/**** + *LIMIT + */ + case function_limit : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("MN"); + /* Get the value from a foo( = ) style call */ + symbol_c *MN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (MN_param_value == NULL) + MN_param_value = function_call_param_iterator.next(); + symbol_c *MN_type_symbol = search_expression_type->get_type(MN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(MN_type_symbol, last_type_symbol) ? search_expression_type->common_type(MN_type_symbol, last_type_symbol) : MN_type_symbol ; + + + { + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + + { + + { + identifier_c param_name("MX"); + /* Get the value from a foo( = ) style call */ + symbol_c *MX_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (MX_param_value == NULL) + MX_param_value = function_call_param_iterator.next(); + symbol_c *MX_type_symbol = search_expression_type->get_type(MX_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(MX_type_symbol, last_type_symbol) ? search_expression_type->common_type(MX_type_symbol, last_type_symbol) : MX_type_symbol ; + + + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_limit*/ + break; + +/**** + *MUX + */ + case function_mux : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("K"); + /* Get the value from a foo( = ) style call */ + symbol_c *K_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (K_param_value == NULL) + K_param_value = function_call_param_iterator.next(); + symbol_c *K_type_symbol = search_expression_type->get_type(K_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(K_type_symbol, last_type_symbol) ? search_expression_type->common_type(K_type_symbol, last_type_symbol) : K_type_symbol ; + + if(search_expression_type->is_integer_type(K_type_symbol)) + { + + { + identifier_c param_name("IN0"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN0_param_value == NULL) + IN0_param_value = function_call_param_iterator.next(); + symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; + + + { + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mux*/ + break; + +/**** + *GT + */ + case function_gt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_gt*/ + break; + +/**** + *GE + */ + case function_ge : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_ge*/ + break; + +/**** + *EQ + */ + case function_eq : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_eq*/ + break; + +/**** + *LT + */ + case function_lt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_lt*/ + break; + +/**** + *LE + */ + case function_le : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_le*/ + break; + +/**** + *NE + */ + case function_ne : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_ne*/ + break; + +/**** + *LEN + */ + case function_len : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_len*/ + break; + +/**** + *LEFT + */ + case function_left : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_left*/ + break; + +/**** + *RIGHT + */ + case function_right : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_right*/ + break; + +/**** + *MID + */ + case function_mid : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mid*/ + break; + +/**** + *CONCAT + */ + case function_concat : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_concat*/ + break; + +/**** + *INSERT + */ + case function_insert : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_insert*/ + break; + +/**** + *DELETE + */ + case function_delete : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_delete*/ + break; + +/**** + *REPLACE + */ + case function_replace : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_replace*/ + break; + +/**** + *FIND + */ + case function_find : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_find*/ + break; + + case function_none : + ERROR; + } + return NULL; +} + +void *compute_standard_function_il(il_function_call_c *symbol, symbol_c *param_data_type) { + + function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name); + function_call_param_iterator_c function_call_param_iterator(symbol); + search_expression_type_c* search_expression_type = this; + + switch(current_function_type){ + +/**** + *BOOL_TO_SINT + */ + case function_bool_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_sint*/ + break; + +/**** + *BOOL_TO_INT + */ + case function_bool_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_int*/ + break; + +/**** + *BOOL_TO_DINT + */ + case function_bool_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_dint*/ + break; + +/**** + *BOOL_TO_LINT + */ + case function_bool_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_lint*/ + break; + +/**** + *BOOL_TO_USINT + */ + case function_bool_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_usint*/ + break; + +/**** + *BOOL_TO_UINT + */ + case function_bool_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_uint*/ + break; + +/**** + *BOOL_TO_UDINT + */ + case function_bool_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_udint*/ + break; + +/**** + *BOOL_TO_ULINT + */ + case function_bool_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_ulint*/ + break; + +/**** + *BOOL_TO_REAL + */ + case function_bool_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_real*/ + break; + +/**** + *BOOL_TO_LREAL + */ + case function_bool_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_lreal*/ + break; + +/**** + *BOOL_TO_TIME + */ + case function_bool_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_time*/ + break; + +/**** + *BOOL_TO_DATE + */ + case function_bool_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_date*/ + break; + +/**** + *BOOL_TO_TOD + */ + case function_bool_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_tod*/ + break; + +/**** + *BOOL_TO_DT + */ + case function_bool_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_dt*/ + break; + +/**** + *BOOL_TO_STRING + */ + case function_bool_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_string*/ + break; + +/**** + *BOOL_TO_BYTE + */ + case function_bool_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_byte*/ + break; + +/**** + *BOOL_TO_WORD + */ + case function_bool_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_word*/ + break; + +/**** + *BOOL_TO_DWORD + */ + case function_bool_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_dword*/ + break; + +/**** + *BOOL_TO_LWORD + */ + case function_bool_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bool_to_lword*/ + break; + +/**** + *SINT_TO_BOOL + */ + case function_sint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_bool*/ + break; + +/**** + *SINT_TO_INT + */ + case function_sint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_int*/ + break; + +/**** + *SINT_TO_DINT + */ + case function_sint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_dint*/ + break; + +/**** + *SINT_TO_LINT + */ + case function_sint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_lint*/ + break; + +/**** + *SINT_TO_USINT + */ + case function_sint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_usint*/ + break; + +/**** + *SINT_TO_UINT + */ + case function_sint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_uint*/ + break; + +/**** + *SINT_TO_UDINT + */ + case function_sint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_udint*/ + break; + +/**** + *SINT_TO_ULINT + */ + case function_sint_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_ulint*/ + break; + +/**** + *SINT_TO_REAL + */ + case function_sint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_real*/ + break; + +/**** + *SINT_TO_LREAL + */ + case function_sint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_lreal*/ + break; + +/**** + *SINT_TO_TIME + */ + case function_sint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_time*/ + break; + +/**** + *SINT_TO_DATE + */ + case function_sint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_date*/ + break; + +/**** + *SINT_TO_TOD + */ + case function_sint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_tod*/ + break; + +/**** + *SINT_TO_DT + */ + case function_sint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_dt*/ + break; + +/**** + *SINT_TO_STRING + */ + case function_sint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_string*/ + break; + +/**** + *SINT_TO_BYTE + */ + case function_sint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_byte*/ + break; + +/**** + *SINT_TO_WORD + */ + case function_sint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_word*/ + break; + +/**** + *SINT_TO_DWORD + */ + case function_sint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_dword*/ + break; + +/**** + *SINT_TO_LWORD + */ + case function_sint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sint_to_lword*/ + break; + +/**** + *INT_TO_BOOL + */ + case function_int_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_bool*/ + break; + +/**** + *INT_TO_SINT + */ + case function_int_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_sint*/ + break; + +/**** + *INT_TO_DINT + */ + case function_int_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_dint*/ + break; + +/**** + *INT_TO_LINT + */ + case function_int_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_lint*/ + break; + +/**** + *INT_TO_USINT + */ + case function_int_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_usint*/ + break; + +/**** + *INT_TO_UINT + */ + case function_int_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_uint*/ + break; + +/**** + *INT_TO_UDINT + */ + case function_int_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_udint*/ + break; + +/**** + *INT_TO_ULINT + */ + case function_int_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_ulint*/ + break; + +/**** + *INT_TO_REAL + */ + case function_int_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_real*/ + break; + +/**** + *INT_TO_LREAL + */ + case function_int_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_lreal*/ + break; + +/**** + *INT_TO_TIME + */ + case function_int_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_time*/ + break; + +/**** + *INT_TO_DATE + */ + case function_int_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_date*/ + break; + +/**** + *INT_TO_TOD + */ + case function_int_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_tod*/ + break; + +/**** + *INT_TO_DT + */ + case function_int_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_dt*/ + break; + +/**** + *INT_TO_STRING + */ + case function_int_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_string*/ + break; + +/**** + *INT_TO_BYTE + */ + case function_int_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_byte*/ + break; + +/**** + *INT_TO_WORD + */ + case function_int_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_word*/ + break; + +/**** + *INT_TO_DWORD + */ + case function_int_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_dword*/ + break; + +/**** + *INT_TO_LWORD + */ + case function_int_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_int_to_lword*/ + break; + +/**** + *DINT_TO_BOOL + */ + case function_dint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_bool*/ + break; + +/**** + *DINT_TO_SINT + */ + case function_dint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_sint*/ + break; + +/**** + *DINT_TO_INT + */ + case function_dint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_int*/ + break; + +/**** + *DINT_TO_LINT + */ + case function_dint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_lint*/ + break; + +/**** + *DINT_TO_USINT + */ + case function_dint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_usint*/ + break; + +/**** + *DINT_TO_UINT + */ + case function_dint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_uint*/ + break; + +/**** + *DINT_TO_UDINT + */ + case function_dint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_udint*/ + break; + +/**** + *DINT_TO_ULINT + */ + case function_dint_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_ulint*/ + break; + +/**** + *DINT_TO_REAL + */ + case function_dint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_real*/ + break; + +/**** + *DINT_TO_LREAL + */ + case function_dint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_lreal*/ + break; + +/**** + *DINT_TO_TIME + */ + case function_dint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_time*/ + break; + +/**** + *DINT_TO_DATE + */ + case function_dint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_date*/ + break; + +/**** + *DINT_TO_TOD + */ + case function_dint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_tod*/ + break; + +/**** + *DINT_TO_DT + */ + case function_dint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_dt*/ + break; + +/**** + *DINT_TO_STRING + */ + case function_dint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_string*/ + break; + +/**** + *DINT_TO_BYTE + */ + case function_dint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_byte*/ + break; + +/**** + *DINT_TO_WORD + */ + case function_dint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_word*/ + break; + +/**** + *DINT_TO_DWORD + */ + case function_dint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_dword*/ + break; + +/**** + *DINT_TO_LWORD + */ + case function_dint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dint_to_lword*/ + break; + +/**** + *LINT_TO_BOOL + */ + case function_lint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_bool*/ + break; + +/**** + *LINT_TO_SINT + */ + case function_lint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_sint*/ + break; + +/**** + *LINT_TO_INT + */ + case function_lint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_int*/ + break; + +/**** + *LINT_TO_DINT + */ + case function_lint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_dint*/ + break; + +/**** + *LINT_TO_USINT + */ + case function_lint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_usint*/ + break; + +/**** + *LINT_TO_UINT + */ + case function_lint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_uint*/ + break; + +/**** + *LINT_TO_UDINT + */ + case function_lint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_udint*/ + break; + +/**** + *LINT_TO_ULINT + */ + case function_lint_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_ulint*/ + break; + +/**** + *LINT_TO_REAL + */ + case function_lint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_real*/ + break; + +/**** + *LINT_TO_LREAL + */ + case function_lint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_lreal*/ + break; + +/**** + *LINT_TO_TIME + */ + case function_lint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_time*/ + break; + +/**** + *LINT_TO_DATE + */ + case function_lint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_date*/ + break; + +/**** + *LINT_TO_TOD + */ + case function_lint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_tod*/ + break; + +/**** + *LINT_TO_DT + */ + case function_lint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_dt*/ + break; + +/**** + *LINT_TO_STRING + */ + case function_lint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_string*/ + break; + +/**** + *LINT_TO_BYTE + */ + case function_lint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_byte*/ + break; + +/**** + *LINT_TO_WORD + */ + case function_lint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_word*/ + break; + +/**** + *LINT_TO_DWORD + */ + case function_lint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_dword*/ + break; + +/**** + *LINT_TO_LWORD + */ + case function_lint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lint_to_lword*/ + break; + +/**** + *USINT_TO_BOOL + */ + case function_usint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_bool*/ + break; + +/**** + *USINT_TO_SINT + */ + case function_usint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_sint*/ + break; + +/**** + *USINT_TO_INT + */ + case function_usint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_int*/ + break; + +/**** + *USINT_TO_DINT + */ + case function_usint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_dint*/ + break; + +/**** + *USINT_TO_LINT + */ + case function_usint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_lint*/ + break; + +/**** + *USINT_TO_UINT + */ + case function_usint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_uint*/ + break; + +/**** + *USINT_TO_UDINT + */ + case function_usint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_udint*/ + break; + +/**** + *USINT_TO_ULINT + */ + case function_usint_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_ulint*/ + break; + +/**** + *USINT_TO_REAL + */ + case function_usint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_real*/ + break; + +/**** + *USINT_TO_LREAL + */ + case function_usint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_lreal*/ + break; + +/**** + *USINT_TO_TIME + */ + case function_usint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_time*/ + break; + +/**** + *USINT_TO_DATE + */ + case function_usint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_date*/ + break; + +/**** + *USINT_TO_TOD + */ + case function_usint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_tod*/ + break; + +/**** + *USINT_TO_DT + */ + case function_usint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_dt*/ + break; + +/**** + *USINT_TO_STRING + */ + case function_usint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_string*/ + break; + +/**** + *USINT_TO_BYTE + */ + case function_usint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_byte*/ + break; + +/**** + *USINT_TO_WORD + */ + case function_usint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_word*/ + break; + +/**** + *USINT_TO_DWORD + */ + case function_usint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_dword*/ + break; + +/**** + *USINT_TO_LWORD + */ + case function_usint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_lword*/ + break; + +/**** + *UINT_TO_BOOL + */ + case function_uint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_bool*/ + break; + +/**** + *UINT_TO_SINT + */ + case function_uint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_sint*/ + break; + +/**** + *UINT_TO_INT + */ + case function_uint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_int*/ + break; + +/**** + *UINT_TO_DINT + */ + case function_uint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_dint*/ + break; + +/**** + *UINT_TO_LINT + */ + case function_uint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_lint*/ + break; + +/**** + *UINT_TO_USINT + */ + case function_uint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_usint*/ + break; + +/**** + *UINT_TO_UDINT + */ + case function_uint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_udint*/ + break; + +/**** + *UINT_TO_ULINT + */ + case function_uint_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_ulint*/ + break; + +/**** + *UINT_TO_REAL + */ + case function_uint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_real*/ + break; + +/**** + *UINT_TO_LREAL + */ + case function_uint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_lreal*/ + break; + +/**** + *UINT_TO_TIME + */ + case function_uint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_time*/ + break; + +/**** + *UINT_TO_DATE + */ + case function_uint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_date*/ + break; + +/**** + *UINT_TO_TOD + */ + case function_uint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_tod*/ + break; + +/**** + *UINT_TO_DT + */ + case function_uint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_dt*/ + break; + +/**** + *UINT_TO_STRING + */ + case function_uint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_string*/ + break; + +/**** + *UINT_TO_BYTE + */ + case function_uint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_byte*/ + break; + +/**** + *UINT_TO_WORD + */ + case function_uint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_word*/ + break; + +/**** + *UINT_TO_DWORD + */ + case function_uint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_dword*/ + break; + +/**** + *UINT_TO_LWORD + */ + case function_uint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_lword*/ + break; + +/**** + *UDINT_TO_BOOL + */ + case function_udint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_bool*/ + break; + +/**** + *UDINT_TO_SINT + */ + case function_udint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_sint*/ + break; + +/**** + *UDINT_TO_INT + */ + case function_udint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_int*/ + break; + +/**** + *UDINT_TO_DINT + */ + case function_udint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_dint*/ + break; + +/**** + *UDINT_TO_LINT + */ + case function_udint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_lint*/ + break; + +/**** + *UDINT_TO_USINT + */ + case function_udint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_usint*/ + break; + +/**** + *UDINT_TO_UINT + */ + case function_udint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_uint*/ + break; + +/**** + *UDINT_TO_ULINT + */ + case function_udint_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_ulint*/ + break; + +/**** + *UDINT_TO_REAL + */ + case function_udint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_real*/ + break; + +/**** + *UDINT_TO_LREAL + */ + case function_udint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_lreal*/ + break; + +/**** + *UDINT_TO_TIME + */ + case function_udint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_time*/ + break; + +/**** + *UDINT_TO_DATE + */ + case function_udint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_date*/ + break; + +/**** + *UDINT_TO_TOD + */ + case function_udint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_tod*/ + break; + +/**** + *UDINT_TO_DT + */ + case function_udint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_dt*/ + break; + +/**** + *UDINT_TO_STRING + */ + case function_udint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_string*/ + break; + +/**** + *UDINT_TO_BYTE + */ + case function_udint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_byte*/ + break; + +/**** + *UDINT_TO_WORD + */ + case function_udint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_word*/ + break; + +/**** + *UDINT_TO_DWORD + */ + case function_udint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_dword*/ + break; + +/**** + *UDINT_TO_LWORD + */ + case function_udint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_lword*/ + break; + +/**** + *ULINT_TO_BOOL + */ + case function_ulint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_bool*/ + break; + +/**** + *ULINT_TO_SINT + */ + case function_ulint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_sint*/ + break; + +/**** + *ULINT_TO_INT + */ + case function_ulint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_int*/ + break; + +/**** + *ULINT_TO_DINT + */ + case function_ulint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_dint*/ + break; + +/**** + *ULINT_TO_LINT + */ + case function_ulint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_lint*/ + break; + +/**** + *ULINT_TO_USINT + */ + case function_ulint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_usint*/ + break; + +/**** + *ULINT_TO_UINT + */ + case function_ulint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_uint*/ + break; + +/**** + *ULINT_TO_UDINT + */ + case function_ulint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_udint*/ + break; + +/**** + *ULINT_TO_REAL + */ + case function_ulint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_real*/ + break; + +/**** + *ULINT_TO_LREAL + */ + case function_ulint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_lreal*/ + break; + +/**** + *ULINT_TO_TIME + */ + case function_ulint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_time*/ + break; + +/**** + *ULINT_TO_DATE + */ + case function_ulint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_date*/ + break; + +/**** + *ULINT_TO_TOD + */ + case function_ulint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_tod*/ + break; + +/**** + *ULINT_TO_DT + */ + case function_ulint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_dt*/ + break; + +/**** + *ULINT_TO_STRING + */ + case function_ulint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_string*/ + break; + +/**** + *ULINT_TO_BYTE + */ + case function_ulint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_byte*/ + break; + +/**** + *ULINT_TO_WORD + */ + case function_ulint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_word*/ + break; + +/**** + *ULINT_TO_DWORD + */ + case function_ulint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_dword*/ + break; + +/**** + *ULINT_TO_LWORD + */ + case function_ulint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_lword*/ + break; + +/**** + *REAL_TO_BOOL + */ + case function_real_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_bool*/ + break; + +/**** + *REAL_TO_SINT + */ + case function_real_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_sint*/ + break; + +/**** + *REAL_TO_INT + */ + case function_real_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_int*/ + break; + +/**** + *REAL_TO_DINT + */ + case function_real_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_dint*/ + break; + +/**** + *REAL_TO_LINT + */ + case function_real_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_lint*/ + break; + +/**** + *REAL_TO_USINT + */ + case function_real_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_usint*/ + break; + +/**** + *REAL_TO_UINT + */ + case function_real_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_uint*/ + break; + +/**** + *REAL_TO_UDINT + */ + case function_real_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_udint*/ + break; + +/**** + *REAL_TO_ULINT + */ + case function_real_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_ulint*/ + break; + +/**** + *REAL_TO_LREAL + */ + case function_real_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_lreal*/ + break; + +/**** + *REAL_TO_TIME + */ + case function_real_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_time*/ + break; + +/**** + *REAL_TO_DATE + */ + case function_real_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_date*/ + break; + +/**** + *REAL_TO_TOD + */ + case function_real_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_tod*/ + break; + +/**** + *REAL_TO_DT + */ + case function_real_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_dt*/ + break; + +/**** + *REAL_TO_STRING + */ + case function_real_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_string*/ + break; + +/**** + *REAL_TO_BYTE + */ + case function_real_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_byte*/ + break; + +/**** + *REAL_TO_WORD + */ + case function_real_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_word*/ + break; + +/**** + *REAL_TO_DWORD + */ + case function_real_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_dword*/ + break; + +/**** + *REAL_TO_LWORD + */ + case function_real_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_real_to_lword*/ + break; + +/**** + *LREAL_TO_BOOL + */ + case function_lreal_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_bool*/ + break; + +/**** + *LREAL_TO_SINT + */ + case function_lreal_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_sint*/ + break; + +/**** + *LREAL_TO_INT + */ + case function_lreal_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_int*/ + break; + +/**** + *LREAL_TO_DINT + */ + case function_lreal_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_dint*/ + break; + +/**** + *LREAL_TO_LINT + */ + case function_lreal_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_lint*/ + break; + +/**** + *LREAL_TO_USINT + */ + case function_lreal_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_usint*/ + break; + +/**** + *LREAL_TO_UINT + */ + case function_lreal_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_uint*/ + break; + +/**** + *LREAL_TO_UDINT + */ + case function_lreal_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_udint*/ + break; + +/**** + *LREAL_TO_ULINT + */ + case function_lreal_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_ulint*/ + break; + +/**** + *LREAL_TO_REAL + */ + case function_lreal_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_real*/ + break; + +/**** + *LREAL_TO_TIME + */ + case function_lreal_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_time*/ + break; + +/**** + *LREAL_TO_DATE + */ + case function_lreal_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_date*/ + break; + +/**** + *LREAL_TO_TOD + */ + case function_lreal_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_tod*/ + break; + +/**** + *LREAL_TO_DT + */ + case function_lreal_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_dt*/ + break; + +/**** + *LREAL_TO_STRING + */ + case function_lreal_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_string*/ + break; + +/**** + *LREAL_TO_BYTE + */ + case function_lreal_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_byte*/ + break; + +/**** + *LREAL_TO_WORD + */ + case function_lreal_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_word*/ + break; + +/**** + *LREAL_TO_DWORD + */ + case function_lreal_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_dword*/ + break; + +/**** + *LREAL_TO_LWORD + */ + case function_lreal_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lreal_to_lword*/ + break; + +/**** + *TIME_TO_SINT + */ + case function_time_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_sint*/ + break; + +/**** + *TIME_TO_INT + */ + case function_time_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_int*/ + break; + +/**** + *TIME_TO_DINT + */ + case function_time_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_dint*/ + break; + +/**** + *TIME_TO_LINT + */ + case function_time_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_lint*/ + break; + +/**** + *TIME_TO_USINT + */ + case function_time_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_usint*/ + break; + +/**** + *TIME_TO_UINT + */ + case function_time_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_uint*/ + break; + +/**** + *TIME_TO_UDINT + */ + case function_time_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_udint*/ + break; + +/**** + *TIME_TO_ULINT + */ + case function_time_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_ulint*/ + break; + +/**** + *TIME_TO_REAL + */ + case function_time_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_real*/ + break; + +/**** + *TIME_TO_LREAL + */ + case function_time_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_lreal*/ + break; + +/**** + *TIME_TO_STRING + */ + case function_time_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_string*/ + break; + +/**** + *TIME_TO_BYTE + */ + case function_time_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_byte*/ + break; + +/**** + *TIME_TO_WORD + */ + case function_time_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_word*/ + break; + +/**** + *TIME_TO_DWORD + */ + case function_time_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_dword*/ + break; + +/**** + *TIME_TO_LWORD + */ + case function_time_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_time_to_lword*/ + break; + +/**** + *DATE_TO_SINT + */ + case function_date_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_sint*/ + break; + +/**** + *DATE_TO_INT + */ + case function_date_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_int*/ + break; + +/**** + *DATE_TO_DINT + */ + case function_date_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_dint*/ + break; + +/**** + *DATE_TO_LINT + */ + case function_date_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_lint*/ + break; + +/**** + *DATE_TO_USINT + */ + case function_date_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_usint*/ + break; + +/**** + *DATE_TO_UINT + */ + case function_date_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_uint*/ + break; + +/**** + *DATE_TO_UDINT + */ + case function_date_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_udint*/ + break; + +/**** + *DATE_TO_ULINT + */ + case function_date_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_ulint*/ + break; + +/**** + *DATE_TO_REAL + */ + case function_date_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_real*/ + break; + +/**** + *DATE_TO_LREAL + */ + case function_date_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_lreal*/ + break; + +/**** + *DATE_TO_STRING + */ + case function_date_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_string*/ + break; + +/**** + *DATE_TO_BYTE + */ + case function_date_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_byte*/ + break; + +/**** + *DATE_TO_WORD + */ + case function_date_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_word*/ + break; + +/**** + *DATE_TO_DWORD + */ + case function_date_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_dword*/ + break; + +/**** + *DATE_TO_LWORD + */ + case function_date_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_to_lword*/ + break; + +/**** + *TOD_TO_SINT + */ + case function_tod_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_sint*/ + break; + +/**** + *TOD_TO_INT + */ + case function_tod_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_int*/ + break; + +/**** + *TOD_TO_DINT + */ + case function_tod_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_dint*/ + break; + +/**** + *TOD_TO_LINT + */ + case function_tod_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_lint*/ + break; + +/**** + *TOD_TO_USINT + */ + case function_tod_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_usint*/ + break; + +/**** + *TOD_TO_UINT + */ + case function_tod_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_uint*/ + break; + +/**** + *TOD_TO_UDINT + */ + case function_tod_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_udint*/ + break; + +/**** + *TOD_TO_ULINT + */ + case function_tod_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_ulint*/ + break; + +/**** + *TOD_TO_REAL + */ + case function_tod_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_real*/ + break; + +/**** + *TOD_TO_LREAL + */ + case function_tod_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_lreal*/ + break; + +/**** + *TOD_TO_STRING + */ + case function_tod_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_string*/ + break; + +/**** + *TOD_TO_BYTE + */ + case function_tod_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_byte*/ + break; + +/**** + *TOD_TO_WORD + */ + case function_tod_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_word*/ + break; + +/**** + *TOD_TO_DWORD + */ + case function_tod_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_dword*/ + break; + +/**** + *TOD_TO_LWORD + */ + case function_tod_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tod_to_lword*/ + break; + +/**** + *DT_TO_SINT + */ + case function_dt_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_sint*/ + break; + +/**** + *DT_TO_INT + */ + case function_dt_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_int*/ + break; + +/**** + *DT_TO_DINT + */ + case function_dt_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_dint*/ + break; + +/**** + *DT_TO_LINT + */ + case function_dt_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_lint*/ + break; + +/**** + *DT_TO_USINT + */ + case function_dt_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_usint*/ + break; + +/**** + *DT_TO_UINT + */ + case function_dt_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_uint*/ + break; + +/**** + *DT_TO_UDINT + */ + case function_dt_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_udint*/ + break; + +/**** + *DT_TO_ULINT + */ + case function_dt_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_ulint*/ + break; + +/**** + *DT_TO_REAL + */ + case function_dt_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_real*/ + break; + +/**** + *DT_TO_LREAL + */ + case function_dt_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_lreal*/ + break; + +/**** + *DT_TO_STRING + */ + case function_dt_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_string*/ + break; + +/**** + *DT_TO_BYTE + */ + case function_dt_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_byte*/ + break; + +/**** + *DT_TO_WORD + */ + case function_dt_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_word*/ + break; + +/**** + *DT_TO_DWORD + */ + case function_dt_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_dword*/ + break; + +/**** + *DT_TO_LWORD + */ + case function_dt_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dt_to_lword*/ + break; + +/**** + *STRING_TO_BOOL + */ + case function_string_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_bool*/ + break; + +/**** + *STRING_TO_SINT + */ + case function_string_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_sint*/ + break; + +/**** + *STRING_TO_INT + */ + case function_string_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_int*/ + break; + +/**** + *STRING_TO_DINT + */ + case function_string_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_dint*/ + break; + +/**** + *STRING_TO_LINT + */ + case function_string_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_lint*/ + break; + +/**** + *STRING_TO_USINT + */ + case function_string_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_usint*/ + break; + +/**** + *STRING_TO_UINT + */ + case function_string_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_uint*/ + break; + +/**** + *STRING_TO_UDINT + */ + case function_string_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_udint*/ + break; + +/**** + *STRING_TO_ULINT + */ + case function_string_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_ulint*/ + break; + +/**** + *STRING_TO_REAL + */ + case function_string_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_real*/ + break; + +/**** + *STRING_TO_LREAL + */ + case function_string_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_lreal*/ + break; + +/**** + *STRING_TO_TIME + */ + case function_string_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_time*/ + break; + +/**** + *STRING_TO_DATE + */ + case function_string_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_date*/ + break; + +/**** + *STRING_TO_TOD + */ + case function_string_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_tod*/ + break; + +/**** + *STRING_TO_DT + */ + case function_string_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_dt*/ + break; + +/**** + *STRING_TO_BYTE + */ + case function_string_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_byte*/ + break; + +/**** + *STRING_TO_WORD + */ + case function_string_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_word*/ + break; + +/**** + *STRING_TO_DWORD + */ + case function_string_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_dword*/ + break; + +/**** + *STRING_TO_LWORD + */ + case function_string_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_string_to_lword*/ + break; + +/**** + *BYTE_TO_BOOL + */ + case function_byte_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_bool*/ + break; + +/**** + *BYTE_TO_SINT + */ + case function_byte_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_sint*/ + break; + +/**** + *BYTE_TO_INT + */ + case function_byte_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_int*/ + break; + +/**** + *BYTE_TO_DINT + */ + case function_byte_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_dint*/ + break; + +/**** + *BYTE_TO_LINT + */ + case function_byte_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_lint*/ + break; + +/**** + *BYTE_TO_USINT + */ + case function_byte_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_usint*/ + break; + +/**** + *BYTE_TO_UINT + */ + case function_byte_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_uint*/ + break; + +/**** + *BYTE_TO_UDINT + */ + case function_byte_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_udint*/ + break; + +/**** + *BYTE_TO_ULINT + */ + case function_byte_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_ulint*/ + break; + +/**** + *BYTE_TO_REAL + */ + case function_byte_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_real*/ + break; + +/**** + *BYTE_TO_LREAL + */ + case function_byte_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_lreal*/ + break; + +/**** + *BYTE_TO_TIME + */ + case function_byte_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_time*/ + break; + +/**** + *BYTE_TO_DATE + */ + case function_byte_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_date*/ + break; + +/**** + *BYTE_TO_TOD + */ + case function_byte_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_tod*/ + break; + +/**** + *BYTE_TO_DT + */ + case function_byte_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_dt*/ + break; + +/**** + *BYTE_TO_STRING + */ + case function_byte_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_string*/ + break; + +/**** + *BYTE_TO_WORD + */ + case function_byte_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_word*/ + break; + +/**** + *BYTE_TO_DWORD + */ + case function_byte_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_dword*/ + break; + +/**** + *BYTE_TO_LWORD + */ + case function_byte_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_byte_to_lword*/ + break; + +/**** + *WORD_TO_BOOL + */ + case function_word_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_bool*/ + break; + +/**** + *WORD_TO_SINT + */ + case function_word_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_sint*/ + break; + +/**** + *WORD_TO_INT + */ + case function_word_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_int*/ + break; + +/**** + *WORD_TO_DINT + */ + case function_word_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_dint*/ + break; + +/**** + *WORD_TO_LINT + */ + case function_word_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_lint*/ + break; + +/**** + *WORD_TO_USINT + */ + case function_word_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_usint*/ + break; + +/**** + *WORD_TO_UINT + */ + case function_word_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_uint*/ + break; + +/**** + *WORD_TO_UDINT + */ + case function_word_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_udint*/ + break; + +/**** + *WORD_TO_ULINT + */ + case function_word_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_ulint*/ + break; + +/**** + *WORD_TO_REAL + */ + case function_word_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_real*/ + break; + +/**** + *WORD_TO_LREAL + */ + case function_word_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_lreal*/ + break; + +/**** + *WORD_TO_TIME + */ + case function_word_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_time*/ + break; + +/**** + *WORD_TO_DATE + */ + case function_word_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_date*/ + break; + +/**** + *WORD_TO_TOD + */ + case function_word_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_tod*/ + break; + +/**** + *WORD_TO_DT + */ + case function_word_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_dt*/ + break; + +/**** + *WORD_TO_STRING + */ + case function_word_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_string*/ + break; + +/**** + *WORD_TO_BYTE + */ + case function_word_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_byte*/ + break; + +/**** + *WORD_TO_DWORD + */ + case function_word_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_dword*/ + break; + +/**** + *WORD_TO_LWORD + */ + case function_word_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_word_to_lword*/ + break; + +/**** + *DWORD_TO_BOOL + */ + case function_dword_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_bool*/ + break; + +/**** + *DWORD_TO_SINT + */ + case function_dword_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_sint*/ + break; + +/**** + *DWORD_TO_INT + */ + case function_dword_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_int*/ + break; + +/**** + *DWORD_TO_DINT + */ + case function_dword_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_dint*/ + break; + +/**** + *DWORD_TO_LINT + */ + case function_dword_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_lint*/ + break; + +/**** + *DWORD_TO_USINT + */ + case function_dword_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_usint*/ + break; + +/**** + *DWORD_TO_UINT + */ + case function_dword_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_uint*/ + break; + +/**** + *DWORD_TO_UDINT + */ + case function_dword_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_udint*/ + break; + +/**** + *DWORD_TO_ULINT + */ + case function_dword_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_ulint*/ + break; + +/**** + *DWORD_TO_REAL + */ + case function_dword_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_real*/ + break; + +/**** + *DWORD_TO_LREAL + */ + case function_dword_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_lreal*/ + break; + +/**** + *DWORD_TO_TIME + */ + case function_dword_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_time*/ + break; + +/**** + *DWORD_TO_DATE + */ + case function_dword_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_date*/ + break; + +/**** + *DWORD_TO_TOD + */ + case function_dword_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_tod*/ + break; + +/**** + *DWORD_TO_DT + */ + case function_dword_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_dt*/ + break; + +/**** + *DWORD_TO_STRING + */ + case function_dword_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_string*/ + break; + +/**** + *DWORD_TO_BYTE + */ + case function_dword_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_byte*/ + break; + +/**** + *DWORD_TO_WORD + */ + case function_dword_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_word*/ + break; + +/**** + *DWORD_TO_LWORD + */ + case function_dword_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_dword_to_lword*/ + break; + +/**** + *LWORD_TO_BOOL + */ + case function_lword_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_bool*/ + break; + +/**** + *LWORD_TO_SINT + */ + case function_lword_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_sint*/ + break; + +/**** + *LWORD_TO_INT + */ + case function_lword_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_int*/ + break; + +/**** + *LWORD_TO_DINT + */ + case function_lword_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_dint*/ + break; + +/**** + *LWORD_TO_LINT + */ + case function_lword_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_lint*/ + break; + +/**** + *LWORD_TO_USINT + */ + case function_lword_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_usint*/ + break; + +/**** + *LWORD_TO_UINT + */ + case function_lword_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_uint*/ + break; + +/**** + *LWORD_TO_UDINT + */ + case function_lword_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_udint*/ + break; + +/**** + *LWORD_TO_ULINT + */ + case function_lword_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_ulint*/ + break; + +/**** + *LWORD_TO_REAL + */ + case function_lword_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_real*/ + break; + +/**** + *LWORD_TO_LREAL + */ + case function_lword_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_lreal*/ + break; + +/**** + *LWORD_TO_TIME + */ + case function_lword_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_time*/ + break; + +/**** + *LWORD_TO_DATE + */ + case function_lword_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_date*/ + break; + +/**** + *LWORD_TO_TOD + */ + case function_lword_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_tod*/ + break; + +/**** + *LWORD_TO_DT + */ + case function_lword_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_dt*/ + break; + +/**** + *LWORD_TO_STRING + */ + case function_lword_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_string*/ + break; + +/**** + *LWORD_TO_BYTE + */ + case function_lword_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_byte*/ + break; + +/**** + *LWORD_TO_WORD + */ + case function_lword_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_word*/ + break; + +/**** + *LWORD_TO_DWORD + */ + case function_lword_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_lword_to_dword*/ + break; + +/**** + *TRUNC + */ + case function_trunc : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_trunc*/ + break; + +/**** + *BCD_TO_USINT + */ + case function_bcd_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bcd_to_usint*/ + break; + +/**** + *BCD_TO_UINT + */ + case function_bcd_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bcd_to_uint*/ + break; + +/**** + *BCD_TO_UDINT + */ + case function_bcd_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bcd_to_udint*/ + break; + +/**** + *BCD_TO_ULINT + */ + case function_bcd_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_bcd_to_ulint*/ + break; + +/**** + *USINT_TO_BCD + */ + case function_usint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_usint_to_bcd*/ + break; + +/**** + *UINT_TO_BCD + */ + case function_uint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_uint_to_bcd*/ + break; + +/**** + *UDINT_TO_BCD + */ + case function_udint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_udint_to_bcd*/ + break; + +/**** + *ULINT_TO_BCD + */ + case function_ulint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ulint_to_bcd*/ + break; + +/**** + *DATE_AND_TIME_TO_TIME_OF_DAY + */ + case function_date_and_time_to_time_of_day : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_and_time_to_time_of_day*/ + break; + +/**** + *DATE_AND_TIME_TO_DATE + */ + case function_date_and_time_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_date_and_time_to_date*/ + break; + +/**** + *ABS + */ + case function_abs : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_abs*/ + break; + +/**** + *SQRT + */ + case function_sqrt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sqrt*/ + break; + +/**** + *LN + */ + case function_ln : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_ln*/ + break; + +/**** + *LOG + */ + case function_log : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_log*/ + break; + +/**** + *EXP + */ + case function_exp : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_exp*/ + break; + +/**** + *SIN + */ + case function_sin : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_sin*/ + break; + +/**** + *COS + */ + case function_cos : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_cos*/ + break; + +/**** + *TAN + */ + case function_tan : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_tan*/ + break; + +/**** + *ASIN + */ + case function_asin : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_asin*/ + break; + +/**** + *ACOS + */ + case function_acos : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_acos*/ + break; + +/**** + *ATAN + */ + case function_atan : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_atan*/ + break; + +/**** + *ADD + */ + case function_add : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_add*/ + break; + +/**** + *MUL + */ + case function_mul : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mul*/ + break; + +/**** + *SUB + */ + case function_sub : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_sub*/ + break; + +/**** + *DIV + */ + case function_div : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_div*/ + break; + +/**** + *MOD + */ + case function_mod : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mod*/ + break; + +/**** + *EXPT + */ + case function_expt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_expt*/ + break; + +/**** + *MOVE + */ + case function_move : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_num_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_move*/ + break; + +/**** + *SHL + */ + case function_shl : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_binary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_shl*/ + break; + +/**** + *SHR + */ + case function_shr : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_binary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_shr*/ + break; + +/**** + *ROR + */ + case function_ror : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_nbinary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_ror*/ + break; + +/**** + *ROL + */ + case function_rol : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_nbinary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_rol*/ + break; + +/**** + *AND + */ + case function_and : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_binary_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_binary_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_and*/ + break; + +/**** + *OR + */ + case function_or : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_binary_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_binary_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_or*/ + break; + +/**** + *XOR + */ + case function_xor : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_binary_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_binary_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_xor*/ + break; + +/**** + *NOT + */ + case function_not : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_binary_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_not*/ + break; + +/**** + *SEL + */ + case function_sel : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *G_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN0"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN0_param_value == NULL) + IN0_param_value = function_call_param_iterator.next(); + symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; + + + { + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_sel*/ + break; + +/**** + *MAX + */ + case function_max : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_max*/ + break; + +/**** + *MIN + */ + case function_min : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_min*/ + break; + +/**** + *LIMIT + */ + case function_limit : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *MN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + + { + + { + identifier_c param_name("MX"); + /* Get the value from a foo( = ) style call */ + symbol_c *MX_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (MX_param_value == NULL) + MX_param_value = function_call_param_iterator.next(); + symbol_c *MX_type_symbol = search_expression_type->get_type(MX_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(MX_type_symbol, last_type_symbol) ? search_expression_type->common_type(MX_type_symbol, last_type_symbol) : MX_type_symbol ; + + + { + + symbol_c * return_type_symbol = IN_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_limit*/ + break; + +/**** + *MUX + */ + case function_mux : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *K_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_integer_type(K_type_symbol)) + { + + { + identifier_c param_name("IN0"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN0_param_value == NULL) + IN0_param_value = function_call_param_iterator.next(); + symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; + + + { + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mux*/ + break; + +/**** + *GT + */ + case function_gt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_gt*/ + break; + +/**** + *GE + */ + case function_ge : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_ge*/ + break; + +/**** + *EQ + */ + case function_eq : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_eq*/ + break; + +/**** + *LT + */ + case function_lt : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_lt*/ + break; + +/**** + *LE + */ + case function_le : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_le*/ + break; + +/**** + *NE + */ + case function_ne : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_ne*/ + break; + +/**** + *LEN + */ + case function_len : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + }/*function_len*/ + break; + +/**** + *LEFT + */ + case function_left : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_left*/ + break; + +/**** + *RIGHT + */ + case function_right : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_right*/ + break; + +/**** + *MID + */ + case function_mid : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mid*/ + break; + +/**** + *CONCAT + */ + case function_concat : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_concat*/ + break; + +/**** + *INSERT + */ + case function_insert : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_insert*/ + break; + +/**** + *DELETE + */ + case function_delete : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_delete*/ + break; + +/**** + *REPLACE + */ + case function_replace : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_replace*/ + break; + +/**** + *FIND + */ + case function_find : + { + symbol_c *last_type_symbol = NULL; + + { + symbol_c *IN1_type_symbol = param_data_type; + last_type_symbol = param_data_type; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + return return_type_symbol; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_find*/ + break; + + case function_none : + ERROR; + } + return NULL; +} diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/search_var_instance_decl.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/search_var_instance_decl.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,505 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + +/* Determine the data type of a specific variable instance, including + * function block instances. + * A reference to the relevant variable declaration is returned. + * The variable instance may NOT be a member of a structure of a memeber + * of a structure of an element of an array of ... + * + * example: + * window.points[1].coordinate.x + * window.points[1].colour + * etc... ARE NOT ALLOWED! + * + * This class must only be passed the name of the variable that will appear + * in the variable declaration. In the above examples, this would be + * 'window' !! + * + * + * If you need to pass a complete name of a variable instance (such as + * 'window.points[1].coordinate.x') use the search_varfb_instance_type_c instead! + */ +/* Note that current_type_decl that this class returns may reference the + * name of a type, or the type declaration itself! + * For an example of the first, consider a variable declared as ... + * x : AAA; + * where the AAA type is previously declared as whatever. + * For an example of the second, consider a variable declared as ... + * x : array of int [10]; ----> is allowed + * + * If it is the first, we will return a reference to the name, if the second + * we return a reference to the declaration!! + */ +class search_var_instance_decl_c: public search_visitor_c { + + private: + symbol_c *search_scope; + symbol_c *search_name; + symbol_c *current_type_decl; + + /* variable used to store the type of variable currently being processed... */ + /* Will contain a single value of generate_c_vardecl_c::XXXX_vt */ + unsigned int current_vartype; + + public: + search_var_instance_decl_c(symbol_c *search_scope) { + this->current_vartype = none_vt; + this->search_scope = search_scope; + this->search_name = NULL; + this->current_type_decl = NULL; + } + + symbol_c *get_decl(symbol_c *variable_instance_name) { + this->search_name = variable_instance_name; + return (symbol_c *)search_scope->accept(*this); + } + + unsigned int get_vartype() { + return current_vartype; + } + + public: + + /* the types of variables that need to be processed... */ + static const unsigned int none_vt = 0x0000; + static const unsigned int input_vt = 0x0001; // VAR_INPUT + static const unsigned int output_vt = 0x0002; // VAR_OUTPUT + static const unsigned int inoutput_vt = 0x0004; // VAR_IN_OUT + static const unsigned int private_vt = 0x0008; // VAR + static const unsigned int temp_vt = 0x0010; // VAR_TEMP + static const unsigned int external_vt = 0x0020; // VAR_EXTERNAL + static const unsigned int global_vt = 0x0040; // VAR_GLOBAL + static const unsigned int located_vt = 0x0080; // VAR AT + + +/***************************/ +/* B 0 - Programming Model */ +/***************************/ + void *visit(library_c *symbol) { + /* we do not want to search multiple declaration scopes, + * so we do not visit all the functions, fucntion blocks, etc... + */ + return NULL; + } + + + +/******************************************/ +/* B 1.4.3 - Declaration & Initialisation */ +/******************************************/ +/* edge -> The F_EDGE or R_EDGE directive */ +// SYM_REF2(edge_declaration_c, edge, var1_list) +// TODO + + void *visit(input_declarations_c *symbol) { + current_vartype = input_vt; + void *res = symbol->input_declaration_list->accept(*this); + if (res == NULL) { + current_vartype = none_vt; + } + return res; + } + +/* VAR_OUTPUT [RETAIN | NON_RETAIN] var_init_decl_list END_VAR */ +/* option -> may be NULL ! */ + void *visit(output_declarations_c *symbol) { + current_vartype = output_vt; + void *res = symbol->var_init_decl_list->accept(*this); + if (res == NULL) { + current_vartype = none_vt; + } + return res; + } + +/* VAR_IN_OUT var_declaration_list END_VAR */ + void *visit(input_output_declarations_c *symbol) { + current_vartype = inoutput_vt; + void *res = symbol->var_declaration_list->accept(*this); + if (res == NULL) { + current_vartype = none_vt; + } + return res; + } + +/* VAR [CONSTANT] var_init_decl_list END_VAR */ +/* option -> may be NULL ! */ +/* helper symbol for input_declarations */ + void *visit(var_declarations_c *symbol) { + current_vartype = private_vt; + void *res = symbol->var_init_decl_list->accept(*this); + if (res == NULL) { + current_vartype = none_vt; + } + return res; + } + +/* VAR RETAIN var_init_decl_list END_VAR */ + void *visit(retentive_var_declarations_c *symbol) { + current_vartype = private_vt; + void *res = symbol->var_init_decl_list->accept(*this); + if (res == NULL) { + current_vartype = none_vt; + } + return res; + } + +/* VAR [CONSTANT|RETAIN|NON_RETAIN] located_var_decl_list END_VAR */ +/* option -> may be NULL ! */ +//SYM_REF2(located_var_declarations_c, option, located_var_decl_list) + void *visit(located_var_declarations_c *symbol) { + current_vartype = located_vt; + void *res = symbol->located_var_decl_list->accept(*this); + if (res == NULL) { + current_vartype = none_vt; + } + return res; + } + +/*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */ +/* option -> may be NULL ! */ +//SYM_REF2(external_var_declarations_c, option, external_declaration_list) + void *visit(external_var_declarations_c *symbol) { + current_vartype = external_vt; + void *res = symbol->external_declaration_list->accept(*this); + if (res == NULL) { + current_vartype = none_vt; + } + return res; + } + +/*| VAR_GLOBAL [CONSTANT|RETAIN] global_var_decl_list END_VAR */ +/* option -> may be NULL ! */ +//SYM_REF2(global_var_declarations_c, option, global_var_decl_list) + void *visit(global_var_declarations_c *symbol) { + current_vartype = global_vt; + void *res = symbol->global_var_decl_list->accept(*this); + if (res == NULL) { + current_vartype = none_vt; + } + return res; + } + +/* var1_list is one of the following... + * simple_spec_init_c * + * subrange_spec_init_c * + * enumerated_spec_init_c * + */ +// SYM_REF2(var1_init_decl_c, var1_list, spec_init) + void *visit(var1_init_decl_c *symbol) { + current_type_decl = symbol->spec_init; + return symbol->var1_list->accept(*this); + } + +/* var1_list ',' variable_name */ +// SYM_LIST(var1_list_c) + void *visit(var1_list_c *symbol) { + list_c *list = symbol; + for(int i = 0; i < list->n; i++) { + if (compare_identifiers(list->elements[i], search_name) == 0) + /* by now, current_type_decl should be != NULL */ + return current_type_decl; + } + return NULL; + } + +/* name_list ':' function_block_type_name ASSIGN structure_initialization */ +/* structure_initialization -> may be NULL ! */ + void *visit(fb_name_decl_c *symbol) { + current_type_decl = symbol->function_block_type_name; + return symbol->fb_name_list->accept(*this); + } + +/* name_list ',' fb_name */ + void *visit(fb_name_list_c *symbol) { + list_c *list = symbol; + for(int i = 0; i < list->n; i++) { + if (compare_identifiers(list->elements[i], search_name) == 0) + /* by now, current_fb_declaration should be != NULL */ + return current_type_decl; + } + return NULL; + } + +/* var1_list ':' array_spec_init */ +// SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init) + void *visit(array_var_init_decl_c *symbol) { + current_type_decl = symbol->array_spec_init; + return symbol->var1_list->accept(*this); + } + +/* var1_list ':' initialized_structure */ +// SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure) + void *visit(structured_var_init_decl_c *symbol) { + current_type_decl = symbol->initialized_structure; + return symbol->var1_list->accept(*this); + } + +/* var1_list ':' array_specification */ +// SYM_REF2(array_var_declaration_c, var1_list, array_specification) + void *visit(array_var_declaration_c *symbol) { + current_type_decl = symbol->array_specification; + return symbol->var1_list->accept(*this); + } + +/* var1_list ':' structure_type_name */ +// SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name) + void *visit(structured_var_declaration_c *symbol) { + current_type_decl = symbol->structure_type_name; + return symbol->var1_list->accept(*this); + } + +/* [variable_name] location ':' located_var_spec_init */ +/* variable_name -> may be NULL ! */ +// SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused) +// TODO!! + +/* global_var_name ':' (simple_specification|subrange_specification|enumerated_specification|array_specification|prev_declared_structure_type_name|function_block_type_name */ +// SYM_REF2(external_declaration_c, global_var_name, specification) + void *visit(external_declaration_c *symbol) { + if (compare_identifiers(symbol->global_var_name, search_name) == 0) + return symbol->specification; + return NULL; + } + +/*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */ +/* type_specification ->may be NULL ! */ +// SYM_REF2(global_var_decl_c, global_var_spec, type_specification) + void *visit(global_var_decl_c *symbol) { + if (symbol->type_specification != NULL) { + current_type_decl = symbol->type_specification; + return symbol->global_var_spec->accept(*this); + } + else + return NULL; + } + +/*| global_var_name location */ +//SYM_REF2(global_var_spec_c, global_var_name, location) + void *visit(global_var_spec_c *symbol) { + if (symbol->global_var_name != NULL && compare_identifiers(symbol->global_var_name, search_name) == 0) + return current_type_decl; + else + return symbol->location->accept(*this); + } + +/*| global_var_list ',' global_var_name */ +//SYM_LIST(global_var_list_c) + void *visit(global_var_list_c *symbol) { + list_c *list = symbol; + for(int i = 0; i < list->n; i++) { + if (compare_identifiers(list->elements[i], search_name) == 0) + /* by now, current_type_decl should be != NULL */ + return current_type_decl; + } + return NULL; + } + +/* [variable_name] location ':' located_var_spec_init */ +/* variable_name -> may be NULL ! */ +//SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused) + void *visit(located_var_decl_c *symbol) { + if (symbol->variable_name != NULL && compare_identifiers(symbol->variable_name, search_name) == 0) { + return symbol->located_var_spec_init; + } + else + return NULL; + } + +/*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */ +/* type_specification ->may be NULL ! */ +// SYM_REF2(global_var_decl_c, global_var_spec, type_specification) +// TODO!! + +/*| global_var_name location */ +// SYM_REF2(global_var_spec_c, global_var_name, location) +// TODO!! + +/* AT direct_variable */ +// SYM_REF2(location_c, direct_variable, unused) +// TODO!! + +/*| global_var_list ',' global_var_name */ +// SYM_LIST(global_var_list_c) +// TODO!! + +/* var1_list ':' single_byte_string_spec */ +// SYM_REF2(single_byte_string_var_declaration_c, var1_list, single_byte_string_spec) + void *visit(single_byte_string_var_declaration_c *symbol) { + current_type_decl = symbol->single_byte_string_spec; + return symbol->var1_list->accept(*this); + } + +/* STRING ['[' integer ']'] [ASSIGN single_byte_character_string] */ +/* integer ->may be NULL ! */ +/* single_byte_character_string ->may be NULL ! */ +// SYM_REF2(single_byte_string_spec_c, integer, single_byte_character_string) +// TODO!! + +/* var1_list ':' double_byte_string_spec */ +// SYM_REF2(double_byte_string_var_declaration_c, var1_list, double_byte_string_spec) + void *visit(double_byte_string_var_declaration_c *symbol) { + current_type_decl = symbol->double_byte_string_spec; + return symbol->var1_list->accept(*this); + } + +/* WSTRING ['[' integer ']'] [ASSIGN double_byte_character_string] */ +/* integer ->may be NULL ! */ +/* double_byte_character_string ->may be NULL ! */ +// SYM_REF2(double_byte_string_spec_c, integer, double_byte_character_string) +// TODO!! + +/* variable_name incompl_location ':' var_spec */ +// SYM_REF4(incompl_located_var_decl_c, variable_name, incompl_location, var_spec, unused) +// TODO!! + +/* AT incompl_location_token */ +// SYM_TOKEN(incompl_location_c) +// TODO!! + + +/**************************************/ +/* B.1.5 - Program organization units */ +/**************************************/ +/***********************/ +/* B 1.5.1 - Functions */ +/***********************/ +// SYM_REF4(function_declaration_c, derived_function_name, type_name, var_declarations_list, function_body) + void *visit(function_declaration_c *symbol) { + /* functions have a variable named after themselves, to store + * the variable that will be returned!! + */ + if (compare_identifiers(symbol->derived_function_name, search_name) == 0) + return symbol->type_name; + + /* no need to search through all the body, so we only + * visit the variable declarations...! + */ + return symbol->var_declarations_list->accept(*this); + } + +/*****************************/ +/* B 1.5.2 - Function Blocks */ +/*****************************/ + void *visit(function_block_declaration_c *symbol) { + /* no need to search through all the body, so we only + * visit the variable declarations...! + */ + return symbol->var_declarations->accept(*this); + } + +/**********************/ +/* B 1.5.3 - Programs */ +/**********************/ + void *visit(program_declaration_c *symbol) { + /* no need to search through all the body, so we only + * visit the variable declarations...! + */ + return symbol->var_declarations->accept(*this); + } + + +/********************************/ +/* B 1.7 Configuration elements */ +/********************************/ + +/* +CONFIGURATION configuration_name + optional_global_var_declarations + (resource_declaration_list | single_resource_declaration) + optional_access_declarations + optional_instance_specific_initializations +END_CONFIGURATION +*/ +/* +SYM_REF6(configuration_declaration_c, configuration_name, global_var_declarations, resource_declarations, access_declarations, instance_specific_initializations, unused) +*/ + void *visit(configuration_declaration_c *symbol) { + /* no need to search through all the configuration, so we only + * visit the global variable declarations...! + */ + if (symbol->global_var_declarations != NULL) + return symbol->global_var_declarations->accept(*this); + else + return NULL; + } + +/* +RESOURCE resource_name ON resource_type_name + optional_global_var_declarations + single_resource_declaration +END_RESOURCE +*/ +// SYM_REF4(resource_declaration_c, resource_name, resource_type_name, global_var_declarations, resource_declaration) + void *visit(resource_declaration_c *symbol) { + /* no need to search through all the resource, so we only + * visit the global variable declarations...! + */ + if (symbol->global_var_declarations != NULL) + return symbol->global_var_declarations->accept(*this); + else + return NULL; + } + +/* task_configuration_list program_configuration_list */ +// SYM_REF2(single_resource_declaration_c, task_configuration_list, program_configuration_list) + void *visit(single_resource_declaration_c *symbol) { + /* no need to search through all the resource, + * and there is no global variable declarations...! + */ + return NULL; + } + +#if 0 +/*********************/ +/* B 1.4 - Variables */ +/*********************/ +SYM_REF2(symbolic_variable_c, var_name, unused) + +/********************************************/ +/* B.1.4.1 Directly Represented Variables */ +/********************************************/ +SYM_TOKEN(direct_variable_c) + +/*************************************/ +/* B.1.4.2 Multi-element Variables */ +/*************************************/ +/* subscripted_variable '[' subscript_list ']' */ +SYM_REF2(array_variable_c, subscripted_variable, subscript_list) + +/* subscript_list ',' subscript */ +SYM_LIST(subscript_list_c) + +/* record_variable '.' field_selector */ +/* WARNING: input and/or output variables of function blocks + * may be accessed as fields of a tructured variable! + * Code handling a structured_variable_c must take + * this into account! + */ +SYM_REF2(structured_variable_c, record_variable, field_selector) + + +#endif +}; + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/search_varfb_instance_type.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/search_varfb_instance_type.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,293 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + + +/* Determine the data type of a variable. + * The variable may be a simple variable, a function block instance, a + * struture element within a data structured type (a struct or a fb), or + * an array element. + * A mixture of array element of a structure element of a structure element + * of a .... is also suported! + * + * A reference to the relevant base type __definition__ is returned. + * This means that if we find that the variable is of type MY_INT, + * which was previously declared to be + * TYPE MY_INT: INT := 9; + * this class wil return INT, and __not__ MY_INT !! + * + * + * example: + * window.points[1].coordinate.x + * window.points[1].colour + * etc... ARE ALLOWED! + * + * This class must be passed the scope within which the + * variable was declared, and the variable name... + */ +class search_varfb_instance_type_c: public search_base_type_c { + private: + search_var_instance_decl_c search_var_instance_decl; + decompose_var_instance_name_c *decompose_var_instance_name; + symbol_c *current_structelement_name; + + public: + search_varfb_instance_type_c(symbol_c *search_scope): search_var_instance_decl(search_scope) { + this->decompose_var_instance_name = NULL; + this->current_structelement_name = NULL; + } + + + symbol_c *get_type(symbol_c *variable_name) { + this->current_structelement_name = NULL; + this->decompose_var_instance_name = new decompose_var_instance_name_c(variable_name); + if (NULL == decompose_var_instance_name) ERROR; + + /* find the part of the variable name that will appear in the + * variable declaration, for e.g., in window.point.x, this would be + * window! + */ + symbol_c *var_name_part = decompose_var_instance_name->next_part(); + if (NULL == var_name_part) ERROR; + + /* Now we try to find the variable instance declaration, to determine its type... */ + symbol_c *var_decl = search_var_instance_decl.get_decl(var_name_part); + if (NULL == var_decl) { + /* variable instance declaration not found! */ + return NULL; + } + + /* if it is a struct or function block, we must search the type + * of the struct or function block member. + * This is done by this class visiting the var_decl. + * This class, while visiting, will recursively call + * decompose_var_instance_name->get_next() when and if required... + */ + symbol_c *res = (symbol_c *)var_decl->accept(*this); + if (NULL == res) ERROR; + + /* make sure that we have decomposed all strcuture elements of the variable name */ + symbol_c *var_name = decompose_var_instance_name->next_part(); + if (NULL != var_name) ERROR; + + return res; + } + + unsigned int get_vartype(symbol_c *variable_name) { + this->current_structelement_name = NULL; + this->decompose_var_instance_name = new decompose_var_instance_name_c(variable_name); + if (NULL == decompose_var_instance_name) ERROR; + + /* find the part of the variable name that will appear in the + * variable declaration, for e.g., in window.point.x, this would be + * window! + */ + symbol_c *var_name_part = decompose_var_instance_name->next_part(); + if (NULL == var_name_part) ERROR; + + /* Now we try to find the variable instance declaration, to determine its type... */ + symbol_c *var_decl = search_var_instance_decl.get_decl(var_name_part); + if (NULL == var_decl) { + /* variable instance declaration not found! */ + return 0; + } + + /* if it is a struct or function block, we must search the type + * of the struct or function block member. + * This is done by this class visiting the var_decl. + * This class, while visiting, will recursively call + * decompose_var_instance_name->get_next() when and if required... + */ + unsigned int res = search_var_instance_decl.get_vartype(); + + /* make sure that we have decomposed all strcuture elements of the variable name */ + symbol_c *var_name = decompose_var_instance_name->next_part(); + if (NULL != var_name) ERROR; + + return res; + } + + private: + /* a helper function... */ + void *visit_list(list_c *list) { + if (NULL == current_structelement_name) ERROR; + + for(int i = 0; i < list->n; i++) { + void *res = list->elements[i]->accept(*this); + if (res != NULL) + return res; + } + /* not found! */ + return NULL; + } + + /* a helper function... */ + void *base_type(symbol_c *symbol) { + search_base_type_c search_base_type; + return symbol->accept(search_base_type); + } + + + private: + /* We override the base class' visitor to identifier_c. + * This is so because the base class does not consider a function block + * to be a type, unlike this class that allows a variable instance + * of a function block type... + */ + void *visit(identifier_c *type_name) { + /* look up the type declaration... */ + symbol_c *fb_decl = function_block_type_symtable.find_value(type_name); + if (fb_decl != function_block_type_symtable.end_value()) + /* Type declaration found!! */ + return fb_decl->accept(*this); + + /* No. It is not a function block, so we let + * the base class take care of it... + */ + return search_base_type_c::visit(type_name); + } + +/********************************/ +/* B 1.3.3 - Derived data types */ +/********************************/ +/* structure_type_name ':' structure_specification */ + void *visit(structure_type_declaration_c *symbol) { + return symbol->structure_specification->accept(*this); + /* NOTE: structure_specification will point to either a + * initialized_structure_c + * OR A + * structure_element_declaration_list_c + */ + } + +/* structure_type_name ASSIGN structure_initialization */ +/* structure_initialization may be NULL ! */ +// SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization) + void *visit(initialized_structure_c *symbol) { + /* make sure that we have decomposed all strcuture elements of the variable name */ + symbol_c *var_name = decompose_var_instance_name->next_part(); + if (NULL == var_name) { + /* this is it... ! + * No need to look any further... + */ + /* NOTE: we could simply do a + * return (void *)symbol; + * nevertheless, note that this search_varfb_instance_type_c + * class inherits from the search_base_type_c class, + * which means that it will usually return the base type, + * and not the derived type (*). If we are to be consistent, + * we should guarantee that we always return the base type. + * To do this we could use + * return (void *)symbol->accept(*this); + * since this class inherits from the search_base_type_c. + * However, in this case we don't want it to follow + * the structs as this search_varfb_instance_type_c does. + * We therefore have to create a new search_base_type_c + * instance to search through this type without going + * through the structs... + */ + return base_type(symbol->structure_type_name); + } + + /* now search the structure declaration */ + current_structelement_name = var_name; + /* recursively find out the data type of var_name... */ + return symbol->structure_type_name->accept(*this); + } + +/* helper symbol for structure_declaration */ +/* structure_declaration: STRUCT structure_element_declaration_list END_STRUCT */ +/* structure_element_declaration_list structure_element_declaration ';' */ + void *visit(structure_element_declaration_list_c *symbol) {return visit_list(symbol);} + +/* structure_element_name ':' spec_init */ + void *visit(structure_element_declaration_c *symbol) { + if (NULL == current_structelement_name) ERROR; + + if (compare_identifiers(symbol->structure_element_name, current_structelement_name) == 0) + return symbol->spec_init->accept(*this); + + return NULL; + } + +/* helper symbol for structure_initialization */ +/* structure_initialization: '(' structure_element_initialization_list ')' */ +/* structure_element_initialization_list ',' structure_element_initialization */ + void *visit(structure_element_initialization_list_c *symbol) {ERROR; return NULL;} /* should never get called... */ +/* structure_element_name ASSIGN value */ + void *visit(structure_element_initialization_c *symbol) {ERROR; return NULL;} /* should never get called... */ + + + +/**************************************/ +/* B.1.5 - Program organization units */ +/**************************************/ +/*****************************/ +/* B 1.5.2 - Function Blocks */ +/*****************************/ +/* FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */ +// SYM_REF4(function_block_declaration_c, fblock_name, var_declarations, fblock_body, unused) + void *visit(function_block_declaration_c *symbol) { + /* make sure that we have decomposed all strcuture elements of the variable name */ + + symbol_c *var_name = decompose_var_instance_name->next_part(); + if (NULL == var_name) { + /* this is it... ! + * No need to look any further... + * Note also that, unlike for the struct types, a function block may + * not be defined based on another (i.e. no inheritance is allowed), + * so this function block is already the most base type. + * We simply return it. + */ + return (void *)symbol; + } + + /* now search the function block declaration for the variable... */ + search_var_instance_decl_c search_decl(symbol); + symbol_c *var_decl = search_decl.get_decl(var_name); + if (NULL == var_decl) { + /* variable instance declaration not found! */ + return NULL; + } + + /* We have found the declaration. + * Should we look any further? + */ + var_name = decompose_var_instance_name->next_part(); + if (NULL == var_name) { + /* this is it... ! */ + return base_type(var_decl); + } + + current_structelement_name = var_name; + /* recursively find out the data type of var_name... */ + return symbol->var_declarations->accept(*this); + } + +}; + + + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/spec_init_separator.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/spec_init_separator.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,169 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * Seperation of type specification and default value constructs + * (for e.g. simple_spec_init_c), into a type specificiation part, + * and a default value part. + */ + + + + +//#include /* required for NULL */ +//#include +//#include + +//#include "../../util/symtable.hh" + + + + + + + +class spec_init_sperator_c: public null_visitor_c { + private: + /* this is a singleton class... */ + static spec_init_sperator_c *class_instance; + static spec_init_sperator_c *get_class_instance(void) { + if (NULL == class_instance) + class_instance = new spec_init_sperator_c(); + + if (NULL == class_instance) + ERROR; + + return class_instance; + } + + private: + typedef enum {search_spec, search_init} search_what_t; + static search_what_t search_what; + + public: + /* the only two public functions... */ + static symbol_c *get_spec(symbol_c *spec_init) { + search_what = search_spec; + return (symbol_c *)spec_init->accept(*get_class_instance()); + } + + static symbol_c *get_init(symbol_c *spec_init) { + search_what = search_init; + return (symbol_c *)spec_init->accept(*get_class_instance()); + } + +// private: + public: /* probably needs to be public so it may be visited... !! */ + + +/*******************************************/ +/* B 1.1 - Letters, digits and identifiers */ +/*******************************************/ +// SYM_TOKEN(identifier_c) +void *visit(identifier_c *symbol) { + TRACE("spec_init_sperator_c::identifier_c"); + switch (search_what) { + /* if we ever get called sith a simple identifier_c, then it must be a previously declared type... */ + case search_spec: return symbol; + case search_init: return NULL; + } + ERROR; /* should never occur */ + return NULL; +} + + +/********************************/ +/* B 1.3.3 - Derived data types */ +/********************************/ + +/* simple_specification ASSIGN constant */ +void *visit(simple_spec_init_c *symbol) { + TRACE("spec_init_sperator_c::simple_spec_init_c"); + switch (search_what) { + case search_spec: return symbol->simple_specification; + case search_init: return symbol->constant; + } + ERROR; /* should never occur */ + return NULL; +} + +/* subrange_specification ASSIGN signed_integer */ +void *visit(subrange_spec_init_c *symbol) { + TRACE("spec_init_sperator_c::subrange_spec_init_c"); + switch (search_what) { + case search_spec: return symbol->subrange_specification; + case search_init: return symbol->signed_integer; + } + ERROR; /* should never occur */ + return NULL; +} + +/* enumerated_specification ASSIGN enumerated_value */ +void *visit(enumerated_spec_init_c *symbol) { + TRACE("spec_init_sperator_c::enumerated_spec_init_c"); + switch (search_what) { + case search_spec: return symbol->enumerated_specification; + case search_init: return symbol->enumerated_value; + } + ERROR; /* should never occur */ + return NULL; +} + +/* structure_type_name ASSIGN structure_initialization */ +/* structure_initialization may be NULL ! */ +//SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization) +void *visit(initialized_structure_c *symbol) { + TRACE("spec_init_sperator_c::initialized_structure_c"); + switch (search_what) { + case search_spec: return symbol->structure_type_name; + case search_init: return symbol->structure_initialization; + } + ERROR; /* should never occur */ + return NULL; +} + + +/******************************************/ +/* B 1.4.3 - Declaration & Initialisation */ +/******************************************/ + +/* fb_name_list ':' function_block_type_name ASSIGN structure_initialization */ +/* structure_initialization -> may be NULL ! */ +void *visit(fb_name_decl_c *symbol) { + TRACE("spec_init_sperator_c::fb_name_decl_c"); + switch (search_what) { + case search_spec: return symbol->function_block_type_name; + case search_init: return symbol->structure_initialization; + } + ERROR; /* should never occur */ + return NULL; +} + +}; /* class spec_init_sperator_c */ + + + +spec_init_sperator_c *spec_init_sperator_c ::class_instance = NULL; +spec_init_sperator_c::search_what_t spec_init_sperator_c::search_what; diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/st_code_gen.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/st_code_gen.c Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,16973 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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 lib + * generated code, do not edit by hand + */ +switch(current_function_type){ + +/**** + *BOOL_TO_SINT + */ + case function_bool_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_sint*/ + break; + +/**** + *BOOL_TO_INT + */ + case function_bool_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_int*/ + break; + +/**** + *BOOL_TO_DINT + */ + case function_bool_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_dint*/ + break; + +/**** + *BOOL_TO_LINT + */ + case function_bool_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_lint*/ + break; + +/**** + *BOOL_TO_USINT + */ + case function_bool_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_usint*/ + break; + +/**** + *BOOL_TO_UINT + */ + case function_bool_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_uint*/ + break; + +/**** + *BOOL_TO_UDINT + */ + case function_bool_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_udint*/ + break; + +/**** + *BOOL_TO_ULINT + */ + case function_bool_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_ulint*/ + break; + +/**** + *BOOL_TO_REAL + */ + case function_bool_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_real*/ + break; + +/**** + *BOOL_TO_LREAL + */ + case function_bool_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_lreal*/ + break; + +/**** + *BOOL_TO_TIME + */ + case function_bool_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_time*/ + break; + +/**** + *BOOL_TO_DATE + */ + case function_bool_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_date*/ + break; + +/**** + *BOOL_TO_TOD + */ + case function_bool_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_tod*/ + break; + +/**** + *BOOL_TO_DT + */ + case function_bool_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_dt*/ + break; + +/**** + *BOOL_TO_STRING + */ + case function_bool_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bool_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_string*/ + break; + +/**** + *BOOL_TO_BYTE + */ + case function_bool_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_byte*/ + break; + +/**** + *BOOL_TO_WORD + */ + case function_bool_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_word*/ + break; + +/**** + *BOOL_TO_DWORD + */ + case function_bool_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_dword*/ + break; + +/**** + *BOOL_TO_LWORD + */ + case function_bool_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_bool_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__sint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_sint_to_lword*/ + break; + +/**** + *INT_TO_BOOL + */ + case function_int_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_bool*/ + break; + +/**** + *INT_TO_SINT + */ + case function_int_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_sint*/ + break; + +/**** + *INT_TO_DINT + */ + case function_int_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_dint*/ + break; + +/**** + *INT_TO_LINT + */ + case function_int_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_lint*/ + break; + +/**** + *INT_TO_USINT + */ + case function_int_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_usint*/ + break; + +/**** + *INT_TO_UINT + */ + case function_int_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_uint*/ + break; + +/**** + *INT_TO_UDINT + */ + case function_int_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_udint*/ + break; + +/**** + *INT_TO_ULINT + */ + case function_int_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_ulint*/ + break; + +/**** + *INT_TO_REAL + */ + case function_int_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_real*/ + break; + +/**** + *INT_TO_LREAL + */ + case function_int_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_lreal*/ + break; + +/**** + *INT_TO_TIME + */ + case function_int_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_time*/ + break; + +/**** + *INT_TO_DATE + */ + case function_int_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_date*/ + break; + +/**** + *INT_TO_TOD + */ + case function_int_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_tod*/ + break; + +/**** + *INT_TO_DT + */ + case function_int_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_dt*/ + break; + +/**** + *INT_TO_STRING + */ + case function_int_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__sint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_string*/ + break; + +/**** + *INT_TO_BYTE + */ + case function_int_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_byte*/ + break; + +/**** + *INT_TO_WORD + */ + case function_int_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_word*/ + break; + +/**** + *INT_TO_DWORD + */ + case function_int_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_dword*/ + break; + +/**** + *INT_TO_LWORD + */ + case function_int_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_int_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__sint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dint_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__sint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lint_to_lword*/ + break; + +/**** + *USINT_TO_BOOL + */ + case function_usint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_sint*/ + break; + +/**** + *USINT_TO_INT + */ + case function_usint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_lreal*/ + break; + +/**** + *USINT_TO_TIME + */ + case function_usint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_lword*/ + break; + +/**** + *ULINT_TO_BOOL + */ + case function_ulint_to_bool : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_bool*/ + break; + +/**** + *ULINT_TO_SINT + */ + case function_ulint_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_sint*/ + break; + +/**** + *ULINT_TO_INT + */ + case function_ulint_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_int*/ + break; + +/**** + *ULINT_TO_DINT + */ + case function_ulint_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_dint*/ + break; + +/**** + *ULINT_TO_LINT + */ + case function_ulint_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_lint*/ + break; + +/**** + *ULINT_TO_USINT + */ + case function_ulint_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_usint*/ + break; + +/**** + *ULINT_TO_UINT + */ + case function_ulint_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_uint*/ + break; + +/**** + *ULINT_TO_UDINT + */ + case function_ulint_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_udint*/ + break; + +/**** + *ULINT_TO_REAL + */ + case function_ulint_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_real*/ + break; + +/**** + *ULINT_TO_LREAL + */ + case function_ulint_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_lreal*/ + break; + +/**** + *ULINT_TO_TIME + */ + case function_ulint_to_time : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_time*/ + break; + +/**** + *ULINT_TO_DATE + */ + case function_ulint_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_date*/ + break; + +/**** + *ULINT_TO_TOD + */ + case function_ulint_to_tod : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_tod*/ + break; + +/**** + *ULINT_TO_DT + */ + case function_ulint_to_dt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_dt*/ + break; + +/**** + *ULINT_TO_STRING + */ + case function_ulint_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_string*/ + break; + +/**** + *ULINT_TO_BYTE + */ + case function_ulint_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_byte*/ + break; + +/**** + *ULINT_TO_WORD + */ + case function_ulint_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_word*/ + break; + +/**** + *ULINT_TO_DWORD + */ + case function_ulint_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_dword*/ + break; + +/**** + *ULINT_TO_LWORD + */ + case function_ulint_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_bool*/ + break; + +/**** + *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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_real_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__real_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lreal_to_lword*/ + break; + +/**** + *TIME_TO_SINT + */ + case function_time_to_sint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_sint*/ + break; + +/**** + *TIME_TO_INT + */ + case function_time_to_int : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_int*/ + break; + +/**** + *TIME_TO_DINT + */ + case function_time_to_dint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_dint*/ + break; + +/**** + *TIME_TO_LINT + */ + case function_time_to_lint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_lint*/ + break; + +/**** + *TIME_TO_USINT + */ + case function_time_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_usint*/ + break; + +/**** + *TIME_TO_UINT + */ + case function_time_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_uint*/ + break; + +/**** + *TIME_TO_UDINT + */ + case function_time_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_udint*/ + break; + +/**** + *TIME_TO_ULINT + */ + case function_time_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_ulint*/ + break; + +/**** + *TIME_TO_REAL + */ + case function_time_to_real : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_real*/ + break; + +/**** + *TIME_TO_LREAL + */ + case function_time_to_lreal : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_lreal*/ + break; + +/**** + *TIME_TO_STRING + */ + case function_time_to_string : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_string*/ + break; + +/**** + *TIME_TO_BYTE + */ + case function_time_to_byte : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_byte*/ + break; + +/**** + *TIME_TO_WORD + */ + case function_time_to_word : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_word*/ + break; + +/**** + *TIME_TO_DWORD + */ + case function_time_to_dword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_dword*/ + break; + +/**** + *TIME_TO_LWORD + */ + case function_time_to_lword : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_time_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__date_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__tod_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tod_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__dt_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__time_to_int("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dt_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_bool("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_sint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_sint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_sint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_sint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_real("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_bit("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_bit("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_bit("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__string_to_bit("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_string_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bit_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_byte_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bit_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_dword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_word_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bit_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_dword_to_lword*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_bool*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_sint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_int*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_dint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_lint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_usint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_uint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_udint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_ulint*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_real*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_lreal*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_time*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_date*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_tod*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__int_to_time("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_dt*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bit_to_string("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_string*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_byte*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_word*/ + 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( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_lword_to_dword*/ + break; + +/**** + *TRUNC + */ + case function_trunc : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + s4o.print("(int)"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_trunc*/ + break; + +/**** + *BCD_TO_USINT + */ + case function_bcd_to_usint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bcd_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bcd_to_usint*/ + break; + +/**** + *BCD_TO_UINT + */ + case function_bcd_to_uint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bcd_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bcd_to_uint*/ + break; + +/**** + *BCD_TO_UDINT + */ + case function_bcd_to_udint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bcd_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bcd_to_udint*/ + break; + +/**** + *BCD_TO_ULINT + */ + case function_bcd_to_ulint : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__bcd_to_uint("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_bcd_to_ulint*/ + break; + +/**** + *USINT_TO_BCD + */ + case function_usint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_bcd("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_usint_to_bcd*/ + break; + +/**** + *UINT_TO_BCD + */ + case function_uint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_bcd("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_uint_to_bcd*/ + break; + +/**** + *UDINT_TO_BCD + */ + case function_udint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_bcd("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_udint_to_bcd*/ + break; + +/**** + *ULINT_TO_BCD + */ + case function_ulint_to_bcd : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; + s4o.print("("); + return_type_symbol->accept(*this); + s4o.print(")__uint_to_bcd("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ulint_to_bcd*/ + break; + +/**** + *DATE_AND_TIME_TO_TIME_OF_DAY + */ + case function_date_and_time_to_time_of_day : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("__date_and_time_to_time_of_day("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_and_time_to_time_of_day*/ + break; + +/**** + *DATE_AND_TIME_TO_DATE + */ + case function_date_and_time_to_date : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; + s4o.print("__date_and_time_to_date("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_date_and_time_to_date*/ + break; + +/**** + *ABS + */ + case function_abs : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_num_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("__abs_"); + IN_type_symbol->accept(*this); + s4o.print("("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_abs*/ + break; + +/**** + *SQRT + */ + case function_sqrt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("sqrt("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sqrt*/ + break; + +/**** + *LN + */ + case function_ln : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("ln("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_ln*/ + break; + +/**** + *LOG + */ + case function_log : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("log("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_log*/ + break; + +/**** + *EXP + */ + case function_exp : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("exp("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_exp*/ + break; + +/**** + *SIN + */ + case function_sin : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("sin("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_sin*/ + break; + +/**** + *COS + */ + case function_cos : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("cos("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_cos*/ + break; + +/**** + *TAN + */ + case function_tan : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("tan("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_tan*/ + break; + +/**** + *ASIN + */ + case function_asin : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("asin("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_asin*/ + break; + +/**** + *ACOS + */ + case function_acos : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("acos("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_acos*/ + break; + +/**** + *ATAN + */ + case function_atan : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_real_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("atan("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_atan*/ + break; + +/**** + *ADD + */ + case function_add : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("+\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print("+\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("__time_add("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("__time_add("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_add("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_add*/ + break; + +/**** + *MUL + */ + case function_mul : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("*\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print("*\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_mul("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mul*/ + break; + +/**** + *SUB + */ + case function_sub : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("-\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_sub("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_sub("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("__time_sub("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_sub("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; + s4o.print("__time_sub("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_sub("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_sub*/ + break; + +/**** + *DIV + */ + case function_div : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("/\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; + s4o.print("__time_div("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_div*/ + break; + +/**** + *MOD + */ + case function_mod : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("%\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mod*/ + break; + +/**** + *EXPT + */ + case function_expt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_num_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_num_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.print("pow("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_expt*/ + break; + +/**** + *MOVE + */ + case function_move : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_num_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_move*/ + break; + +/**** + *SHL + */ + case function_shl : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_binary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + IN_param_value->accept(*this); + s4o.print("<<"); + N_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_shl*/ + break; + +/**** + *SHR + */ + case function_shr : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_binary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + IN_param_value->accept(*this); + s4o.print(">>"); + N_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_shr*/ + break; + +/**** + *ROR + */ + case function_ror : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_nbinary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("__ror_"); + IN_type_symbol->accept(*this); + s4o.print("("); + IN_param_value->accept(*this); + s4o.print(", "); + N_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_ror*/ + break; + +/**** + *ROL + */ + case function_rol : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_nbinary_type(IN_type_symbol)) + { + + { + identifier_c param_name("N"); + /* Get the value from a foo( = ) style call */ + symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (N_param_value == NULL) + N_param_value = function_call_param_iterator.next(); + symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; + + if(search_expression_type->is_integer_type(N_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("__rol_"); + IN_type_symbol->accept(*this); + s4o.print("("); + IN_param_value->accept(*this); + s4o.print(", "); + N_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_rol*/ + break; + +/**** + *AND + */ + case function_and : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_binary_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_binary_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("("); + if (search_expression_type->is_bool_type(last_type_symbol)) + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("&\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print("&\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + if (search_expression_type->is_bool_type(last_type_symbol)) { + s4o.print("&1"); + s4o.print(")"); + } + s4o.print(""); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_and*/ + break; + +/**** + *OR + */ + case function_or : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_binary_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_binary_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("("); + if (search_expression_type->is_bool_type(last_type_symbol)) + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("|\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print("|\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + if (search_expression_type->is_bool_type(last_type_symbol)) { + s4o.print("&1"); + s4o.print(")"); + } + s4o.print(""); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_or*/ + break; + +/**** + *XOR + */ + case function_xor : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_binary_type(IN1_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_binary_type(IN2_type_symbol)) + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("("); + if (search_expression_type->is_bool_type(last_type_symbol)) + s4o.print("(\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print("^\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print("^\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + if (search_expression_type->is_bool_type(last_type_symbol)) { + s4o.print("&1"); + s4o.print(")"); + } + s4o.print(""); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_xor*/ + break; + +/**** + *NOT + */ + case function_not : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_binary_type(IN_type_symbol)) + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("~"); + IN_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + }/*function_not*/ + break; + +/**** + *SEL + */ + case function_sel : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("G"); + /* Get the value from a foo( = ) style call */ + symbol_c *G_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (G_param_value == NULL) + G_param_value = function_call_param_iterator.next(); + symbol_c *G_type_symbol = search_expression_type->get_type(G_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(G_type_symbol, last_type_symbol) ? search_expression_type->common_type(G_type_symbol, last_type_symbol) : G_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN0"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN0_param_value == NULL) + IN0_param_value = function_call_param_iterator.next(); + symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; + + + { + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + G_param_value->accept(*this); + s4o.print(" ? "); + IN1_param_value->accept(*this); + s4o.print(" : "); + IN0_param_value->accept(*this); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_sel*/ + break; + +/**** + *MAX + */ + case function_max : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("__max_"); + return_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_max*/ + break; + +/**** + *MIN + */ + case function_min : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("__min_"); + return_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_min*/ + break; + +/**** + *LIMIT + */ + case function_limit : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("MN"); + /* Get the value from a foo( = ) style call */ + symbol_c *MN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (MN_param_value == NULL) + MN_param_value = function_call_param_iterator.next(); + symbol_c *MN_type_symbol = search_expression_type->get_type(MN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(MN_type_symbol, last_type_symbol) ? search_expression_type->common_type(MN_type_symbol, last_type_symbol) : MN_type_symbol ; + + + { + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + + { + + { + identifier_c param_name("MX"); + /* Get the value from a foo( = ) style call */ + symbol_c *MX_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (MX_param_value == NULL) + MX_param_value = function_call_param_iterator.next(); + symbol_c *MX_type_symbol = search_expression_type->get_type(MX_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(MX_type_symbol, last_type_symbol) ? search_expression_type->common_type(MX_type_symbol, last_type_symbol) : MX_type_symbol ; + + + { + + symbol_c * return_type_symbol = IN_type_symbol; + s4o.print("__limit_"); + IN_type_symbol->accept(*this); + s4o.print("("); + MN_param_value->accept(*this); + s4o.print(", "); + IN_param_value->accept(*this); + s4o.print(", "); + MX_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_limit*/ + break; + +/**** + *MUX + */ + case function_mux : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("K"); + /* Get the value from a foo( = ) style call */ + symbol_c *K_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (K_param_value == NULL) + K_param_value = function_call_param_iterator.next(); + symbol_c *K_type_symbol = search_expression_type->get_type(K_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(K_type_symbol, last_type_symbol) ? search_expression_type->common_type(K_type_symbol, last_type_symbol) : K_type_symbol ; + + if(search_expression_type->is_integer_type(K_type_symbol)) + { + + { + identifier_c param_name("IN0"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN0_param_value == NULL) + IN0_param_value = function_call_param_iterator.next(); + symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; + + + { + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + symbol_c * return_type_symbol = last_type_symbol; + s4o.indent_right(); + s4o.print("__mux_"); + return_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + K_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN0_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + + int base_num = 2; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mux*/ + break; + +/**** + *GT + */ + case function_gt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.indent_right(); + s4o.print("__gt_"); + last_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_gt*/ + break; + +/**** + *GE + */ + case function_ge : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.indent_right(); + s4o.print("__ge_"); + last_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_ge*/ + break; + +/**** + *EQ + */ + case function_eq : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.indent_right(); + s4o.print("__eq_"); + last_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_eq*/ + break; + +/**** + *LT + */ + case function_lt : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.indent_right(); + s4o.print("__lt_"); + last_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_lt*/ + break; + +/**** + *LE + */ + case function_le : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.indent_right(); + s4o.print("__le_"); + last_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_le*/ + break; + +/**** + *NE + */ + case function_ne : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + + { + + symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; + s4o.indent_right(); + s4o.print("__ne_"); + last_type_symbol->accept(*this); + s4o.print("("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_ne*/ + break; + +/**** + *LEN + */ + case function_len : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("__len("); + IN_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + }/*function_len*/ + break; + +/**** + *LEFT + */ + case function_left : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("__left("); + IN_param_value->accept(*this); + s4o.print(", "); + L_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_left*/ + break; + +/**** + *RIGHT + */ + case function_right : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("__right("); + IN_param_value->accept(*this); + s4o.print(", "); + L_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_right*/ + break; + +/**** + *MID + */ + case function_mid : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("__mid("); + IN_param_value->accept(*this); + s4o.print(", "); + L_param_value->accept(*this); + s4o.print(", "); + P_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_mid*/ + break; + +/**** + *CONCAT + */ + case function_concat : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; + s4o.print("__time_add("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.indent_right(); + s4o.print("__concat("); + s4o.print_integer(nb_param); + s4o.print(",\n" + s4o.indent_spaces); + IN1_param_value->accept(*this); + s4o.print(",\n" + s4o.indent_spaces); + IN2_param_value->accept(*this); + + int base_num = 3; + symbol_c *param_value = NULL; + do{ + char my_name[10]; + sprintf(my_name, "IN%d", base_num++); + identifier_c param_name(my_name); + + /* Get the value from a foo( = ) style call */ + param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (param_value == NULL) + param_value = function_call_param_iterator.next(); + if (param_value != NULL){ + symbol_c *current_type_symbol = search_expression_type->get_type(param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; + + /*Function specific CODE */ + s4o.print(",\n" + s4o.indent_spaces); + param_value->accept(*this); + + } + + }while(param_value != NULL); + s4o.print(")"); + s4o.indent_left(); + return NULL; + + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_concat*/ + break; + +/**** + *INSERT + */ + case function_insert : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("__insert("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(", "); + P_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_insert*/ + break; + +/**** + *DELETE + */ + case function_delete : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN_param_value == NULL) + IN_param_value = function_call_param_iterator.next(); + symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("__delete("); + IN_param_value->accept(*this); + s4o.print(", "); + L_param_value->accept(*this); + s4o.print(", "); + P_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_delete*/ + break; + +/**** + *REPLACE + */ + case function_replace : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("L"); + /* Get the value from a foo( = ) style call */ + symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (L_param_value == NULL) + L_param_value = function_call_param_iterator.next(); + symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; + + if(search_expression_type->is_integer_type(L_type_symbol)) + { + + { + identifier_c param_name("P"); + /* Get the value from a foo( = ) style call */ + symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (P_param_value == NULL) + P_param_value = function_call_param_iterator.next(); + symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; + + if(search_expression_type->is_integer_type(P_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; + s4o.print("__replace("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(", "); + L_param_value->accept(*this); + s4o.print(", "); + P_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_replace*/ + break; + +/**** + *FIND + */ + case function_find : + { + symbol_c *last_type_symbol = NULL; + + { + identifier_c param_name("IN1"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN1_param_value == NULL) + IN1_param_value = function_call_param_iterator.next(); + symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + { + identifier_c param_name("IN2"); + /* Get the value from a foo( = ) style call */ + symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); + + /* Get the value from a foo() style call */ + if (IN2_param_value == NULL) + IN2_param_value = function_call_param_iterator.next(); + symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); + last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; + + if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) + { + + symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; + s4o.print("__find("); + IN1_param_value->accept(*this); + s4o.print(", "); + IN2_param_value->accept(*this); + s4o.print(")"); + return NULL; + + } + + ERROR; + } + + } + + ERROR; + } + + }/*function_find*/ + break; + + case function_none : + ERROR; +} +return NULL; diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/type_initial_value.cc --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/type_initial_value.cc Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,378 @@ +/* + * (c) 2003 Mario de Sousa + * + * 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) + * + */ + + +/* + * Determine the default initial value of a type declaration. + * + * This is part of the 4th stage that generates + * a c++ source program equivalent to the IL and ST + * code. + */ + + + + +//#include /* required for NULL */ +//#include +//#include + +//#include "../../util/symtable.hh" + +//#include "generate_c.hh" + + + + + +/* Given a type definition declration, determine its default + * initial value. Note that types based on other types + * may have to iterate through each type it is based on + * to determine the initial value. + * E.g. + * TYPE + * A_t : INT := 10; + * B_t : A_t := 20; + * C_t : B_t; + * D_t : C_t := 40; + * END_TYPE + * Where the default initial value for C_t is 20! + */ +/* NOTE: The main program only needs one instance of + * this class of object. This class + * is therefore a singleton. + */ +class type_initial_value_c : public null_visitor_c { + private: + static type_initial_value_c *_instance; + /* constants for the default values of elementary data types... */ + static real_c *real_0; + static integer_c *integer_0, *integer_1; + static boolean_literal_c *bool_0; + static date_literal_c *date_literal_0; + static daytime_c *daytime_literal_0; + static duration_c *time_0; + static date_c *date_0; + static time_of_day_c *tod_0; + static date_and_time_c *dt_0; + static single_byte_character_string_c *string_0; + static double_byte_character_string_c *wstring_0; + + public: + static type_initial_value_c *instance(void) { + if (_instance != NULL) + return _instance; + + _instance = new type_initial_value_c; + + real_0 = new real_c("0"); + integer_0 = new integer_c("0"); + integer_1 = new integer_c("1"); + bool_0 = new boolean_literal_c(new bool_type_name_c(),new boolean_false_c()); + /* FIXME: Our current implementation only allows dates from 1970 onwards, + * but the standard defines the date 0001-01-01 as the default value + * for the DATE data type. Untill we fix our implementation, we use 1970-01-01 + * as our default value!! + */ +// date_literal_0 = new date_literal_c(integer_1, integer_1, integer_1); + date_literal_0 = new date_literal_c(new integer_c("1970"), integer_1, integer_1); + daytime_literal_0 = new daytime_c(integer_0, integer_0, real_0); + time_0 = new duration_c(NULL, new seconds_c(integer_0, NULL)); // T#0S + date_0 = new date_c(date_literal_0); // D#0001-01-01 + tod_0 = new time_of_day_c(daytime_literal_0); // TOD#00:00:00 + dt_0 = new date_and_time_c(date_literal_0, daytime_literal_0); // DT#0001-01-01-00:00:00 + string_0 = new single_byte_character_string_c("''"); + wstring_0 = new double_byte_character_string_c("\"\""); + + return _instance; + } + + protected: + type_initial_value_c(void) {} + + public: + symbol_c *get(identifier_c *type_name) { + TRACE("type_initial_value_c::get(): called "); + return (symbol_c *)type_name->accept(*this); + } + + + private: + void *handle_type_spec(symbol_c *base_type_name, symbol_c *type_spec_init) { + if (type_spec_init != NULL) + return type_spec_init; + /* no initial value specified, so we return + * the initial value of the type this type is based on... + */ + return base_type_name->accept(*this); + } + + public: + void *visit(identifier_c *type_name) { + /* look up the type declaration... */ + symbol_c *type_decl = type_symtable.find_value(type_name); + if (type_decl == type_symtable.end_value()) + /* Type declaration not found!! */ + /* NOTE: Variables declared out of function block 'data types', + * for eg: VAR timer: TON; END_VAR + * do not have a default value, so (TON) will never be found in the + * type symbol table. This means we cannot simply consider this + * an error and abort, but must rather return a NULL. + */ + return NULL; + + return type_decl->accept(*this); + } + +/***********************************/ +/* B 1.3.1 - Elementary Data Types */ +/***********************************/ + void *visit(time_type_name_c *symbol) {return (void *)time_0;} + void *visit(bool_type_name_c *symbol) {return (void *)bool_0;} + void *visit(sint_type_name_c *symbol) {return (void *)integer_0;} + void *visit(int_type_name_c *symbol) {return (void *)integer_0;} + void *visit(dint_type_name_c *symbol) {return (void *)integer_0;} + void *visit(lint_type_name_c *symbol) {return (void *)integer_0;} + void *visit(usint_type_name_c *symbol) {return (void *)integer_0;} + void *visit(uint_type_name_c *symbol) {return (void *)integer_0;} + void *visit(udint_type_name_c *symbol) {return (void *)integer_0;} + void *visit(ulint_type_name_c *symbol) {return (void *)integer_0;} + void *visit(real_type_name_c *symbol) {return (void *)real_0;} + void *visit(lreal_type_name_c *symbol) {return (void *)real_0;} + void *visit(date_type_name_c *symbol) {return (void *)date_0;} + void *visit(tod_type_name_c *symbol) {return (void *)tod_0;} + void *visit(dt_type_name_c *symbol) {return (void *)dt_0;} + void *visit(byte_type_name_c *symbol) {return (void *)integer_0;} + void *visit(word_type_name_c *symbol) {return (void *)integer_0;} + void *visit(dword_type_name_c *symbol) {return (void *)integer_0;} + void *visit(lword_type_name_c *symbol) {return (void *)integer_0;} + void *visit(string_type_name_c *symbol) {return (void *)string_0;} + void *visit(wstring_type_name_c *symbol) {return (void *)wstring_0;} + +/********************************/ +/* B 1.3.3 - Derived data types */ +/********************************/ +/* simple_type_name ':' simple_spec_init */ + void *visit(simple_type_declaration_c *symbol) { + return symbol->simple_spec_init->accept(*this); + } +/* simple_specification ASSIGN constant */ + void *visit(simple_spec_init_c *symbol) { + return handle_type_spec(symbol->simple_specification, symbol->constant); + } +/* subrange_type_name ':' subrange_spec_init */ + void *visit(subrange_type_declaration_c *symbol) { + return symbol->subrange_spec_init->accept(*this); + } +/* subrange_specification ASSIGN signed_integer */ + void *visit(subrange_spec_init_c *symbol) { + return handle_type_spec(symbol->subrange_specification, symbol->signed_integer); + } +/* integer_type_name '(' subrange')' */ + void *visit(subrange_specification_c *symbol) { + /* if no initial value explicitly given, then use the lowest value of the subrange */ + return symbol->subrange->accept(*this); + } +/* signed_integer DOTDOT signed_integer */ + void *visit(subrange_c *symbol) {return symbol->lower_limit;} +/* enumerated_type_name ':' enumerated_spec_init */ + void *visit(enumerated_type_declaration_c *symbol) { + return symbol->enumerated_spec_init->accept(*this); + } +/* enumerated_specification ASSIGN enumerated_value */ + void *visit(enumerated_spec_init_c *symbol) { + return handle_type_spec(symbol->enumerated_specification, symbol->enumerated_value); + } +/* helper symbol for enumerated_specification->enumerated_spec_init */ +/* enumerated_value_list ',' enumerated_value */ + void *visit(enumerated_value_list_c *symbol) { + /* if no initial value explicitly given, then use the lowest value of the subrange */ + return (void *)symbol->elements[0]; + } +/* enumerated_type_name '#' identifier */ +// SYM_REF2(enumerated_value_c, type, value) + void *visit(enumerated_value_c *symbol) {ERROR; return NULL;} +/* identifier ':' array_spec_init */ + void *visit(array_type_declaration_c *symbol) { + return symbol->array_spec_init->accept(*this); + } +/* array_specification [ASSIGN array_initialization} */ +/* array_initialization may be NULL ! */ + void *visit(array_spec_init_c *symbol) { + return handle_type_spec(symbol->array_specification, symbol->array_initialization); + } +/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */ + void *visit(array_specification_c *symbol) { + symbol_c *init_value = (symbol_c *)symbol->non_generic_type_name->accept(*this); + + /* Now build a array_initial_elements_list_c list, and populate it + * with 1 element of the array_initial_elements_c class + */ + /* The array_initial_elements_c will contain a reference to the init_value, + * and another constant representing the number of elements in the array. + * In essence, we are building the equivilant of the following ST/IL code: + * New_array_t : ARRAY [1..30, 51..60] of INT := [40(XXX)]; + * from the user given code + * New_array_t : ARRAY [1..30, 51..60] of INT; + * and replacing XXX with the default initial value of INT. + */ + /* now we need to determine the number of elements in the array... */ + /* Easier said than done, as the array may have a list of subranges, as in the + * example given above!! + */ + /* TODO !!!!!*/ + /* For now, just assume an array with 1 element. + * I (Mario) want to finish off this part of the code before getting boged down + * in something else... + */ + // NOTE: We are leaking memory, as the integer will never get free'd!! + integer_c *integer = new integer_c("1"); + // NOTE: We are leaking memory, as the array_initial_elements will never get free'd!! + array_initial_elements_c *array_initial_elements = new array_initial_elements_c(integer, init_value); + // NOTE: We are leaking memory, as the array_initial_elements_list will never get free'd!! + array_initial_elements_list_c *array_initial_elements_list = new array_initial_elements_list_c(); + array_initial_elements_list->add_element(array_initial_elements); + return (void *)array_initial_elements_list; + } +/* helper symbol for array_specification */ +/* array_subrange_list ',' subrange */ + void *visit(array_subrange_list_c *symbol) {ERROR; return NULL;} +/* array_initialization: '[' array_initial_elements_list ']' */ +/* helper symbol for array_initialization */ +/* array_initial_elements_list ',' array_initial_elements */ + void *visit(array_initial_elements_list_c *symbol) {ERROR; return NULL;} +/* integer '(' [array_initial_element] ')' */ +/* array_initial_element may be NULL ! */ + void *visit(array_initial_elements_c *symbol) {ERROR; return NULL;} + + + + /* TODO: from this point forward... */ + +/* structure_type_name ':' structure_specification */ + void *visit(structure_type_declaration_c *symbol) {return NULL;} +/* structure_type_name ASSIGN structure_initialization */ +/* structure_initialization may be NULL ! */ + void *visit(initialized_structure_c *symbol) {return NULL;} +/* helper symbol for structure_declaration */ +/* structure_declaration: STRUCT structure_element_declaration_list END_STRUCT */ +/* structure_element_declaration_list structure_element_declaration ';' */ + void *visit(structure_element_declaration_list_c *symbol) {return NULL;} +/* structure_element_name ':' *_spec_init */ + void *visit(structure_element_declaration_c *symbol) {return NULL;} +/* helper symbol for structure_initialization */ +/* structure_initialization: '(' structure_element_initialization_list ')' */ +/* structure_element_initialization_list ',' structure_element_initialization */ + void *visit(structure_element_initialization_list_c *symbol) {return NULL;} +/* structure_element_name ASSIGN value */ + void *visit(structure_element_initialization_c *symbol) {return NULL;} +/* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ +/* + * NOTE: + * (Summary: Contrary to what is expected, the + * string_type_declaration_c is not used to store + * simple string type declarations that do not include + * size limits. + * For e.g.: + * str1_type: STRING := "hello!" + * will be stored in a simple_type_declaration_c + * instead of a string_type_declaration_c. + * The following: + * str2_type: STRING [64] := "hello!" + * will be stored in a sring_type_declaration_c + * + * Read on for why this is done... + * End Summary) + * + * According to the spec, the valid construct + * TYPE new_str_type : STRING := "hello!"; END_TYPE + * has two possible routes to type_declaration... + * + * Route 1: + * type_declaration: single_element_type_declaration + * single_element_type_declaration: simple_type_declaration + * simple_type_declaration: identifier ':' simple_spec_init + * simple_spec_init: simple_specification ASSIGN constant + * (shift: identifier <- 'new_str_type') + * simple_specification: elementary_type_name + * elementary_type_name: STRING + * (shift: elementary_type_name <- STRING) + * (reduce: simple_specification <- elementary_type_name) + * (shift: constant <- "hello!") + * (reduce: simple_spec_init: simple_specification ASSIGN constant) + * (reduce: ...) + * + * + * Route 2: + * type_declaration: string_type_declaration + * string_type_declaration: identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init + * (shift: identifier <- 'new_str_type') + * elementary_string_type_name: STRING + * (shift: elementary_string_type_name <- STRING) + * (shift: string_type_declaration_size <- empty ) + * string_type_declaration_init: ASSIGN character_string + * (shift: character_string <- "hello!") + * (reduce: string_type_declaration_init <- ASSIGN character_string) + * (reduce: string_type_declaration <- identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init ) + * (reduce: type_declaration <- string_type_declaration) + * + * + * At first glance it seems that removing route 1 would make + * the most sense. Unfortunately the construct 'simple_spec_init' + * shows up multiple times in other rules, so changing this construct + * would also mean changing all the rules in which it appears. + * I (Mario) therefore chose to remove route 2 instead. This means + * that the above declaration gets stored in a + * simple_type_declaration_c, and not in a string_type_declaration_c + * as would be expected! + */ +/* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ +#if 0 +SYM_REF4(string_type_declaration_c, string_type_name, + elementary_string_type_name, + string_type_declaration_size, + string_type_declaration_init) /* may be == NULL! */ +#endif + void *visit(string_type_declaration_c *symbol) {return NULL;} +}; + +type_initial_value_c *type_initial_value_c::_instance = NULL; +real_c *type_initial_value_c::real_0 = NULL; +integer_c *type_initial_value_c::integer_0 = NULL; +integer_c *type_initial_value_c::integer_1 = NULL; +boolean_literal_c *type_initial_value_c::bool_0 = NULL; +date_literal_c *type_initial_value_c::date_literal_0 = NULL; +daytime_c *type_initial_value_c::daytime_literal_0 = NULL; +duration_c *type_initial_value_c::time_0 = NULL; +date_c *type_initial_value_c::date_0 = NULL; +time_of_day_c *type_initial_value_c::tod_0 = NULL; +date_and_time_c *type_initial_value_c::dt_0 = NULL; +single_byte_character_string_c *type_initial_value_c::string_0 = NULL; +double_byte_character_string_c *type_initial_value_c::wstring_0 = NULL; + + + + + + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_c/types.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stage4/generate_c/types.h Wed Oct 24 17:39:51 2007 +0200 @@ -0,0 +1,73 @@ +/* + * (c) 2000 Jiri Baum + * Mario de Sousa + * + * 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. + */ + + +#ifndef __PLC_TYPES_H +#define __PLC_TYPES_H + +#include +#include /* some limits related to floats are located here (?) */ + + +/* + * This will need to be conditional on the arquitecture or something. + * Anyone know where we can snarf the relevant magic easily? + */ +typedef double f64; /* 64-bit floating point */ +typedef float f32; /* 32-bit floating point */ + +typedef unsigned long long int u64; /* 64-bit unsigned integer */ +typedef long long int i64; /* 64-bit signed integer */ +typedef unsigned int u32; /* 32-bit unsigned integer */ +typedef int i32; /* 32-bit signed integer */ +typedef unsigned short int u16; /* 16-bit unsigned integer */ +typedef short int i16; /* 16-bit signed integer */ +typedef unsigned char u8; /* 8-bit unsigned integer */ +typedef signed char i8; /* 8-bit signed integer */ + +/* some platforms seem to be missing with the definition of FLT_MAX */ +#ifndef FLT_MAX + /* this is the minimum value guaranteed by ANSI C++ */ + /* does anybody know the minimum value guaranteed for ANSI C ? */ +#define FLT_MAX 1E+37 +#endif +#ifndef FLT_MIN + /* this is the minimum value guaranteed by ANSI C++ */ + /* does anybody know the minimum value guaranteed for ANSI C ? */ +#define FLT_MIN 1E-37 +#endif + +#define f32_MAX FLT_MAX +#define f32_MIN FLT_MIN + +#define u32_MAX UINT_MAX +#define u32_MIN 0 +#define i32_MAX INT_MAX +#define i32_MIN INT_MIN + +#define u16_MAX USHRT_MAX +#define u16_MIN 0 +#define i16_MAX SHRT_MAX +#define i16_MIN SHRT_MIN + +#define u8_MAX UCHAR_MAX +#define u8_MIN 0 +#define i8_MAX SCHAR_MAX +#define i8_MIN SCHAR_MIN + +#endif /* __PLC_TYPES_H */ + diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/.cvsignore --- a/stage4/generate_cc/.cvsignore Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,2 +0,0 @@ -Makefile.depend -test_iec_std_lib diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/Makefile --- a/stage4/generate_cc/Makefile Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,31 +0,0 @@ -# include the system specific Makefile -include ../../Makefile.$(shell uname) - -default: all - -all: generate_cc.o - -clean: - -rm -f *.o */*.o Makefile.depend - -CXXFLAGS += -Wno-unused -CXXFLAGS += -I. -I../* -I../../absyntax - -#how to make things from other directories if they are missing -../% /%: - $(MAKE) -C $(@D) $(@F) - -test_iec_std_lib: test_iec_std_lib.c iec_std_lib.h - gcc -o test_iec_std_lib test_iec_std_lib.c - -test: test_iec_std_lib - -Makefile.depend depend: - $(CXX) -MM -MG -I. *.cc \ - | perl -pe 's/:/ Makefile.depend:/' > Makefile.depend - -include Makefile.depend - - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/decompose_var_instance_name.cc --- a/stage4/generate_cc/decompose_var_instance_name.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,132 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* Decomposes a variable instance name into its constituents, - * example: - * window.points[1].coordinate.x - * - * will succesfully return - * - window - * - points - * - coordinate - * - x - * on succesive calls to decompose_var_instance_name_c::next_part() - */ -class decompose_var_instance_name_c: null_visitor_c { - - private: - symbol_c *variable_name; - symbol_c *next_variable_name; - symbol_c *current_recursive_variable_name; - symbol_c *previously_returned_variable_name; - - public: - decompose_var_instance_name_c(symbol_c *variable_instance_name) { - variable_name = variable_instance_name; - next_variable_name = NULL; - current_recursive_variable_name = NULL; - previously_returned_variable_name = NULL; - } - - public: - symbol_c *next_part(void) { - /* We must always start from the top! - * See note in the structured_variable_c visitor - * to understand why... - */ - symbol_c *res = (symbol_c *)variable_name->accept(*this); - next_variable_name = current_recursive_variable_name; - - if (previously_returned_variable_name == res) - return NULL; - previously_returned_variable_name = res; - return res; - } - - public: -/*********************/ -/* B 1.4 - Variables */ -/*********************/ - void *visit(symbolic_variable_c *symbol) {return (void *)(symbol->var_name);} - -/********************************************/ -/* B.1.4.1 Directly Represented Variables */ -/********************************************/ - void *visit(direct_variable_c *symbol) {return (void *)symbol;} - -/*************************************/ -/* B.1.4.2 Multi-element Variables */ -/*************************************/ -/* subscripted_variable '[' subscript_list ']' */ -// SYM_REF2(array_variable_c, subscripted_variable, subscript_list) - void *visit(array_variable_c *symbol) { - /* NOTE: the subscripted_variable may itself be a structure!, - * so we must recursevily visit! - */ - return symbol->subscripted_variable->accept(*this); - } - -/* record_variable '.' field_selector */ -/* WARNING: input and/or output variables of function blocks - * may be accessed as fields of a tructured variable! - * Code handling a structured_variable_c must take - * this into account! - */ -//SYM_REF2(structured_variable_c, record_variable, field_selector) - void *visit(structured_variable_c *symbol) { - /* NOTE: The following code will not work, as structured_variable_c - * are grouped on the left, and not on the right! - * - * example: window.origin.x - * will result in - * s1 = structured_variable_c("window, "origin"); - * s2 = structured_variable_c(s1, "x"); - * AND NOT - * s1 = structured_variable_c("origin", "x"); - * s2 = structured_variable_c("window", s1); - * - * as the following code assumes!! - * - current_variable_name = symbol->field_selector; - return symbol->record_variable->accept(*this); - */ - - /* The correct code, is therefore more complex... */ - if (next_variable_name == symbol) { - /* NOTE: field_selector is always an identifier_c, - * so we do not have to recursevily visit it again... - * return (void *)symbol->field_selector->accept(*this); -> NOT REQUIRED!! - */ - return (void *)symbol->field_selector; - } - - current_recursive_variable_name = symbol; - return symbol->record_variable->accept(*this); - } -}; - - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/function_call_iterator.cc --- a/stage4/generate_cc/function_call_iterator.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,150 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * Function call parameter iterator. - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the IL and ST - * code. - */ - - -//#include /* required for NULL */ -//#include -//#include - -//#include "../../util/symtable.hh" - -//#include "generate_cc.hh" - - - - -/* given a function_body_c, iterate through each - * function in/out/inout parameter, returning the name - * of each parameter... - */ -class function_call_iterator_c : public iterator_visitor_c { - private: - symbol_c *start_symbol; - int next_fcall, fcall_count; - //identifier_c *current_fcall_name; - symbol_c *current_fcall_name; - //function_invocation_c *current_finvocation; - symbol_c *current_finvocation; - - public: - /* initialise the iterator object. - * We must be given a reference to the function declaration - * that will be analysed... - */ - function_call_iterator_c(symbol_c *symbol) { - this->start_symbol = symbol; - next_fcall = fcall_count = 0; - current_finvocation = NULL; - current_fcall_name = NULL; - } - - /* Skip to the next function call. After object creation, - * the object references _before_ the first, so - * this function must be called once to get the object to - * reference the first function call... - * - * Returns the function_invocation_c! - */ - //function_invocation_c *next(void) {TRACE("function_call_iterator_c::next(): called "); - symbol_c *next(void) {TRACE("function_call_iterator_c::next(): called "); - fcall_count = 0; - next_fcall++; - current_finvocation = NULL; - current_fcall_name = NULL; - - start_symbol->accept(*this); - return current_finvocation; - } - - /* Returns the name of the currently referenced function invocation */ - identifier_c *fname(void) { - identifier_c *identifier = dynamic_cast(current_fcall_name); - if (identifier == NULL) ERROR; - return identifier; - } - - -/***************************************/ -/* B.3 - Language ST (Structured Text) */ -/***************************************/ -/***********************/ -/* B 3.1 - Expressions */ -/***********************/ - void *visit(function_invocation_c *symbol) { - fcall_count++; - if (next_fcall == fcall_count) { - current_finvocation = symbol; - current_fcall_name = symbol->function_name; - } - return NULL; - } - - - -/****************************************/ -/* B.2 - Language IL (Instruction List) */ -/****************************************/ -/***********************************/ -/* B 2.1 Instructions and Operands */ -/***********************************/ - -/* | function_name [il_operand_list] */ -// SYM_REF2(il_function_call_c, function_name, il_operand_list) - void *visit(il_function_call_c *symbol) { - fcall_count++; - if (next_fcall == fcall_count) { - current_finvocation = symbol; - current_fcall_name = symbol->function_name; - } - return NULL; - } - - - -/* | function_name '(' eol_list [il_param_list] ')' */ -// SYM_REF2(il_formal_funct_call_c, function_name, il_param_list) - void *visit(il_formal_funct_call_c *symbol) { - fcall_count++; - if (next_fcall == fcall_count) { - current_finvocation = symbol; - current_fcall_name = symbol->function_name; - } - return NULL; - } - - -}; - - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/function_call_param_iterator.cc --- a/stage4/generate_cc/function_call_param_iterator.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,546 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * Function call parameter iterator. - * It will iterate through the formal parameters of a function call - * (i.e. function calls using the foo(, , ...) syntax). - * and/or search through the non-formal parameters of a function call - * (i.e. function calls using the foo( = , = , ...) syntax). - * - * Calls to function blocks and programs are also supported. - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the IL and ST - * code. - */ - - - - - - -//#include /* required for NULL */ -//#include -//#include - -//#include "../../util/symtable.hh" - -//#include "generate_cc.hh" - - -#include "../../absyntax/visitor.hh" - - -/* - * Function call parameter iterator. - * It will iterate through the formal parameters of a function call - * (i.e. function calls using the foo(, , ...) syntax). - * and/or search through the non-formal parameters of a function call - * (i.e. function calls using the foo( = , = , ...) syntax). - * - * Calls to function blocks and programs are also supported. - * - * Note that calls to next() will only iterate through formal parameters, - * and calls to search() will only serach through non-formal parameters. - */ - -class function_call_param_iterator_c : public null_visitor_c { - private: - /* a pointer to the function call - * (or function block or program call!) - */ - symbol_c *f_call; - int next_param, param_count; - identifier_c *search_param_name; - - /* Which operation of the class was called... - * Search a parameter, or iterate to the next parameter. - */ - typedef enum {iterate_op, search_op} operation_t; - operation_t current_operation; - - private: - void *search_list(list_c *list) { - switch (current_operation) { - case iterate_op: - for(int i = 0; i < list->n; i++) { - void *res = list->elements[i]->accept(*this); - if (NULL != res) { - /* It went through the handle_parameter_assignment() function, - * and is therefore a parameter assignment ( = ), - * and not a simple expression (). - */ - /* we do nothing... */ - } else { - param_count++; - if (param_count == next_param) { - return list->elements[i]; - } - } - } - return NULL; - break; - - case search_op: - for(int i = 0; i < list->n; i++) { - void *res = list->elements[i]->accept(*this); - if (res != NULL) - return res; - } - return NULL; - break; - } /* switch */ - return NULL; - } - - - - void *handle_parameter_assignment(symbol_c *variable_name, symbol_c *expression) { - switch (current_operation) { - case iterate_op: - /* UGLY HACK -> this will be detected in the search_list() function */ - return (void *)this; /* anything, as long as it is not NULL!! */ - break; - - case search_op: - identifier_c *variable_name2 = dynamic_cast(variable_name); - if (variable_name2 == NULL) ERROR; - if (strcasecmp(search_param_name->value, variable_name2->value) == 0) - /* FOUND! This is the same parameter!! */ - return (void *)expression; - return NULL; - break; - } - - ERROR; - return NULL; - } - - - - public: - /* start off at the first parameter once again... */ - void reset(void) { - next_param = param_count = 0; - } - - /* initialise the iterator object. - * We must be given a reference to the function/program/function block call - * that will be analysed... - */ - function_call_param_iterator_c(symbol_c *f_call) { - /* It is expected that f_call will reference one of the following: - * program_configuration_c - * function_invocation_c - * fb_invocation_c - * il_function_call_c - * il_formal_funct_call_c - * ... (have I missed any?) - */ - this->f_call = f_call; - search_param_name = NULL; - reset(); - } - - /* Skip to the next parameter. After object creation, - * the object references on parameter _before_ the first, so - * this function must be called once to get the object to - * reference the first parameter... - * - * Returns whatever is being passed to the parameter! - */ - symbol_c *next(void) { - param_count = 0; - next_param++; - current_operation = function_call_param_iterator_c::iterate_op; - void *res = f_call->accept(*this); - return (symbol_c *)res; - } - - /* Search for the value passed to the parameter named ... */ - symbol_c *search(symbol_c *param_name) { - if (NULL == param_name) ERROR; - search_param_name = dynamic_cast(param_name); - if (NULL == search_param_name) ERROR; - current_operation = function_call_param_iterator_c::search_op; - void *res = f_call->accept(*this); - return (symbol_c *)res; - } - - - - - private: -/********************************/ -/* B 1.7 Configuration elements */ -/********************************/ - -/* -CONFIGURATION configuration_name - optional_global_var_declarations - (resource_declaration_list | single_resource_declaration) - optional_access_declarations - optional_instance_specific_initializations -END_CONFIGURATION -*/ -/* -SYM_REF6(configuration_declaration_c, configuration_name, global_var_declarations, resource_declarations, access_declarations, instance_specific_initializations, unused) -*/ - -/* helper symbol for configuration_declaration */ -/* -SYM_LIST(resource_declaration_list_c) -*/ - -/* -RESOURCE resource_name ON resource_type_name - optional_global_var_declarations - single_resource_declaration -END_RESOURCE -*/ -/* -SYM_REF4(resource_declaration_c, resource_name, resource_type_name, global_var_declarations, resource_declaration) -*/ - -/* task_configuration_list program_configuration_list */ -/* -SYM_REF2(single_resource_declaration_c, task_configuration_list, program_configuration_list) -*/ - -/* helper symbol for single_resource_declaration */ -/* -SYM_LIST(task_configuration_list_c) -*/ - -/* helper symbol for single_resource_declaration */ -/* -SYM_LIST(program_configuration_list_c) -*/ - -/* helper symbol for - * - access_path - * - instance_specific_init - */ -/* -SYM_LIST(any_fb_name_list_c) -*/ - -/* [resource_name '.'] global_var_name ['.' structure_element_name] */ -/* -SYM_REF4(global_var_reference_c, resource_name, global_var_name, structure_element_name, unused) -*/ - -/* prev_declared_program_name '.' symbolic_variable */ -/* -SYM_REF2(program_output_reference_c, program_name, symbolic_variable) -*/ - -/* TASK task_name task_initialization */ -/* -SYM_REF2(task_configuration_c, task_name, task_initialization) -*/ - -/* '(' [SINGLE ASSIGN data_source ','] [INTERVAL ASSIGN data_source ','] PRIORITY ASSIGN integer ')' */ -/* -SYM_REF4(task_initialization_c, single_data_source, interval_data_source, priority_data_source, unused) -*/ - -/* PROGRAM [RETAIN | NON_RETAIN] program_name [WITH task_name] ':' program_type_name ['(' prog_conf_elements ')'] */ -// SYM_REF6(program_configuration_c, retain_option, program_name, task_name, program_type_name, prog_conf_elements, unused) - void *visit(program_configuration_c *symbol) { - TRACE("program_configuration_c"); - return symbol->prog_conf_elements->accept(*this); - } - -/* prog_conf_elements ',' prog_conf_element */ -// SYM_LIST(prog_conf_elements_c) - void *visit(prog_conf_elements_c *symbol) { - TRACE("prog_conf_elements_c"); - return search_list(symbol); - } - -/* fb_name WITH task_name */ -/* -SYM_REF2(fb_task_c, fb_name, task_name) -*/ - -/* any_symbolic_variable ASSIGN prog_data_source */ -// SYM_REF2(prog_cnxn_assign_c, symbolic_variable, prog_data_source) - void *visit(prog_cnxn_assign_c *symbol) { - TRACE("prog_cnxn_assign_c"); - - /* NOTE: symbolic_variable may be something other than a symbolic_variable_c, but I (Mario) - * do not understand the semantics that should be implmeneted if it is not a - * symbolic_variable, so for the moment we simply give up! - */ - symbolic_variable_c *symb_var = dynamic_cast(symbol->symbolic_variable); - if (NULL == symb_var) - ERROR; - - return handle_parameter_assignment(symb_var->var_name, symbol->prog_data_source); - } - -/* any_symbolic_variable SENDTO data_sink */ -// SYM_REF2(prog_cnxn_sendto_c, symbolic_variable, prog_data_source) - void *visit(prog_cnxn_sendto_c *symbol) { - TRACE("prog_cnxn_sendto_c"); - - /* NOTE: symbolic_variable may be something other than a symbolic_variable_c, but I (Mario) - * do not understand the semantics that should be implmeneted if it is not a - * symbolic_variable, so for the moment we simply give up! - */ - symbolic_variable_c *symb_var = dynamic_cast(symbol->symbolic_variable); - if (NULL == symb_var) - ERROR; - - return handle_parameter_assignment(symb_var->var_name, symbol->data_sink); - } - -/* VAR_CONFIG instance_specific_init_list END_VAR */ -/* -SYM_REF2(instance_specific_initializations_c, instance_specific_init_list, unused) -*/ - -/* helper symbol for instance_specific_initializations */ -/* -SYM_LIST(instance_specific_init_list_c) -*/ - -/* resource_name '.' program_name '.' {fb_name '.'} - ((variable_name [location] ':' located_var_spec_init) | (fb_name ':' fb_initialization)) -*/ -/* -SYM_REF6(instance_specific_init_c, resource_name, program_name, any_fb_name_list, variable_name, location, initialization) -*/ - -/* helper symbol for instance_specific_init */ -/* function_block_type_name ':=' structure_initialization */ -/* -SYM_REF2(fb_initialization_c, function_block_type_name, structure_initialization) -*/ - - - - - - -/****************************************/ -/* B.2 - Language IL (Instruction List) */ -/****************************************/ -/***********************************/ -/* B 2.1 Instructions and Operands */ -/***********************************/ - -/* | function_name [il_operand_list] */ -// SYM_REF2(il_function_call_c, function_name, il_operand_list) - void *visit(il_function_call_c *symbol) { - TRACE("il_function_call_c"); - if (NULL != symbol->il_operand_list) - return symbol->il_operand_list->accept(*this); - return NULL; - } - - -/* | function_name '(' eol_list [il_param_list] ')' */ -// SYM_REF2(il_formal_funct_call_c, function_name, il_param_list) - void *visit(il_formal_funct_call_c *symbol) { - TRACE("il_formal_funct_call_c"); - if (NULL != symbol->il_param_list) - return symbol->il_param_list->accept(*this); - return NULL; - } - - -/* il_call_operator prev_declared_fb_name - * | il_call_operator prev_declared_fb_name '(' ')' - * | il_call_operator prev_declared_fb_name '(' eol_list ')' - * | il_call_operator prev_declared_fb_name '(' il_operand_list ')' - * | il_call_operator prev_declared_fb_name '(' eol_list il_param_list ')' - */ -// SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list) - void *visit(il_fb_call_c *symbol) { - TRACE("il_fb_call_c"); - /* the following should never occur. In reality the syntax parser - * will guarantee that they never occur, but it makes it easier to - * understand the remaining code :-) - */ - //if ((NULL == symbol->il_operand_list) && (NULL == symbol->il_param_list)) ERROR; - //if ((NULL != symbol->il_operand_list) && (NULL != symbol->il_param_list)) ERROR; - - if (NULL != symbol->il_operand_list) - return symbol->il_operand_list->accept(*this); - if (NULL != symbol->il_param_list) - return symbol->il_param_list->accept(*this); - return NULL; - } - - - -/* | il_operand_list ',' il_operand */ -// SYM_LIST(il_operand_list_c) - void *visit(il_operand_list_c *symbol) { - TRACE("il_operand_list_c"); - return search_list(symbol); - } - - -/* | il_initial_param_list il_param_instruction */ -// SYM_LIST(il_param_list_c) - void *visit(il_param_list_c *symbol) { - TRACE("il_param_list_c"); - return search_list(symbol); - } - -/* il_assign_operator il_operand - * | il_assign_operator '(' eol_list simple_instr_list ')' - */ -// SYM_REF4(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list, unused) - void *visit(il_param_assignment_c *symbol) { - TRACE("il_param_assignment_c"); - - // TODO : We do not yet handle a instruction list passed as parameter !!! - // since we do not yet support it, it is best to simply stop than to fail silently... - if (NULL != symbol->simple_instr_list) ERROR; - - return handle_parameter_assignment(symbol->il_assign_operator, symbol->il_operand); - } - -/* il_assign_out_operator variable */ -// SYM_REF2(il_param_out_assignment_c, il_assign_out_operator, variable); - void *visit(il_param_out_assignment_c *symbol) { - TRACE("il_param_out_assignment_c"); - return handle_parameter_assignment((symbol_c *)symbol->il_assign_out_operator->accept(*this), symbol->variable); - } - - -/*******************/ -/* B 2.2 Operators */ -/*******************/ -/*| [NOT] any_identifier SENDTO */ -// SYM_REF2(il_assign_out_operator_c, option, variable_name) - void *visit(il_assign_out_operator_c *symbol) { - TRACE("il_assign_out_operator_c"); - - // TODO : Handle not_param !!! - // we do not yet support it, so it is best to simply stop than to fail silently... - if (NULL != symbol->option) ERROR; - - return (void *)symbol->variable_name; - } - - - - -/***************************************/ -/* B.3 - Language ST (Structured Text) */ -/***************************************/ -/***********************/ -/* B 3.1 - Expressions */ -/***********************/ - -/* -SYM_REF2(function_invocation_c, function_name, parameter_assignment_list) -*/ - void *visit(function_invocation_c *symbol) { - TRACE("function_invocation_c"); - if ((symbol_c *)symbol == f_call && symbol->parameter_assignment_list != NULL) - return symbol->parameter_assignment_list->accept(*this); - else - return NULL; - } - - - - -/********************/ -/* B 3.2 Statements */ -/********************/ - -/*********************************/ -/* B 3.2.1 Assignment Statements */ -/*********************************/ -/* -SYM_REF2(assignment_statement_c, l_exp, r_exp) -*/ - -/*****************************************/ -/* B 3.2.2 Subprogram Control Statements */ -/*****************************************/ -/* RETURN */ -// SYM_REF0(return_statement_c) - - -/* fb_name '(' [param_assignment_list] ')' */ -/* param_assignment_list -> may be NULL ! */ -// SYM_REF2(fb_invocation_c, fb_name, param_assignment_list) - void *visit(fb_invocation_c *symbol) { - TRACE("fb_invocation_c"); - if (symbol->param_assignment_list != NULL) - return symbol->param_assignment_list->accept(*this); - else - return NULL; - } - -/* helper symbol for fb_invocation */ -/* param_assignment_list ',' param_assignment */ -// SYM_LIST(param_assignment_list_c) - void *visit(param_assignment_list_c *symbol) { - TRACE("param_assignment_list_c"); - return search_list(symbol); - } - -/* variable_name ASSIGN expression */ -// SYM_REF2(input_variable_param_assignment_c, variable_name, expression) - void *visit(input_variable_param_assignment_c *symbol) { - TRACE("input_variable_param_assignment_c"); - return handle_parameter_assignment(symbol->variable_name, symbol->expression); - } - -/* [NOT] variable_name '=>' variable */ -// SYM_REF4(output_variable_param_assignment_c, not_param, variable_name, variable, unused) - void *visit(output_variable_param_assignment_c *symbol) { - TRACE("output_variable_param_assignment_c"); - // TODO : Handle not_param !!! - if (NULL != symbol->not_param) ERROR; // we do not yet support it, so it is best to simply stop than to fail silently... - - return handle_parameter_assignment(symbol->variable_name, symbol->variable); - } - -/* helper CLASS for output_variable_param_assignment */ -// SYM_REF0(not_paramassign_c) -// TODO... ??? - - - - - -}; - - - - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/function_param_iterator.cc --- a/stage4/generate_cc/function_param_iterator.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,426 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * Function parameter iterator. - * Iterate through the in/out parameters of a function declaration. - * Function blocks are also suported. - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the IL and ST - * code. - */ - - - - - - -//#include /* required for NULL */ -//#include -//#include - -//#include "../../util/symtable.hh" - -//#include "generate_cc.hh" - - -#include "../../absyntax/visitor.hh" - - -/* given a function_declaration_c, iterate through each - * function in/out/inout parameter, returning the name - * of each parameter...function_param_iterator_c - */ -class function_param_iterator_c : public null_visitor_c { - public: - /* A type to specify the type of parameter. - * VAR_INPUT => direction_in - * VAR_OUTPUT => direction_out - * VAR_IN_OUT => direction_inout - * VAR_EXTERNAL => direction_extref - * - * Note that VAR_EXTERNAL declares variables that are in reality references - * to global variables. This is used only inside programs! - * These references to external variables must be correctly initialised to refer - * to the correct global variable. Note that the user may define which variable is to be - * referenced in a CONFIGURATION, and that different instantiations of a program - * may have the same external variable reference diffenrent global variables! - * The references must therefore be correctly initialised when the program instance - * is created. This may be done by the PROGRAM class constructor since the ST and IL - * languages do not allow the VAR_EXTERNAL reference to change at runtime - * for a specific instance. - * - * We therefore need to call a PROGRAM class constructor with the variables - * that should be refernced by the VAR_EXTERNAL variables. The direction_extref will - * be used to identify these parameters! - */ - typedef enum {direction_in, direction_out, direction_inout, direction_extref} param_direction_t ; - - - private: - /* a pointer to the function_block_declaration_c - * or function_declaration_c currently being analysed. - */ - symbol_c *f_decl; - int next_param, param_count; - identifier_c *current_param_name; - symbol_c *current_param_type; - symbol_c *current_param_default_value; - param_direction_t current_param_direction; - - private: - void* handle_param_list(list_c *list) { - if (next_param <= param_count + list->n) - return list->elements[next_param - param_count - 1]; - - /* the desired param is not on this list... */ - param_count += list->n; - return NULL; - } - - void* handle_single_param(symbol_c *var_name) { - param_count++; - if (next_param == param_count) - return var_name; - - /* not yet the desired param... */ - return NULL; - } - - void* iterate_list(list_c *list) { - void *res; - for (int i = 0; i < list->n; i++) { - res = list->elements[i]->accept(*this); - if (res != NULL) - return res; - } - return NULL; - } - - - public: - /* start off at the first parameter once again... */ - void reset(void) { - next_param = param_count = 0; - current_param_name = NULL; - current_param_type = current_param_default_value = NULL; - } - - /* initialise the iterator object. - * We must be given a reference to the function declaration - * that will be analysed... - */ - function_param_iterator_c(function_declaration_c *f_decl) { - this->f_decl = f_decl; - reset(); - } - - /* initialise the iterator object. - * We must be given a reference to the function block declaration - * that will be analysed... - */ - function_param_iterator_c(function_block_declaration_c *fb_decl) { - this->f_decl = fb_decl; - reset(); - } - - /* initialise the iterator object. - * We must be given a reference to the program declaration - * that will be analysed... - */ - function_param_iterator_c(program_declaration_c *p_decl) { - this->f_decl = p_decl; - reset(); - } - - /* Skip to the next parameter. After object creation, - * the object references on parameter _before_ the first, so - * this function must be called once to get the object to - * reference the first parameter... - * - * Returns the parameter's name! - */ - identifier_c *next(void) { - void *res; - param_count = 0; - next_param++; - res = f_decl->accept(*this); - if (res == NULL) - return NULL; - - symbol_c *sym = (symbol_c *)res; - identifier_c *identifier = dynamic_cast(sym); - if (identifier == NULL) - ERROR; - - current_param_name = identifier; - return current_param_name; - } - - /* Returns the currently referenced parameter's default value, - * or NULL if none is specified in the function declrataion itself. - */ - symbol_c *default_value(void) { - return current_param_default_value; - } - - /* Returns the currently referenced parameter's type name. */ - symbol_c *param_type(void) { - return current_param_type; - } - - /* Returns the currently referenced parameter's data passing direction. - * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT - */ - param_direction_t param_direction(void) { - return current_param_direction; - } - -/******************************************/ -/* B 1.4.3 - Declaration & Initialisation */ -/******************************************/ - void *visit(input_declarations_c *symbol) { - TRACE("input_declarations_c"); - current_param_direction = direction_in; - return symbol->input_declaration_list->accept(*this); - } - void *visit(input_declaration_list_c *symbol) {TRACE("input_declaration_list_c"); return iterate_list(symbol);} - void *visit(edge_declaration_c *symbol) {TRACE("edge_declaration_c"); return symbol->var1_list->accept(*this);} - -#if 0 -/* var1_list ':' array_spec_init */ -SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init) - -/* var1_list ':' initialized_structure */ -SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure) - -/* name_list ':' function_block_type_name ASSIGN structure_initialization */ -/* structure_initialization -> may be NULL ! */ -SYM_REF4(fb_name_decl_c, fb_name_list, function_block_type_name, structure_initialization, unused) - -/* name_list ',' fb_name */ -SYM_LIST(fb_name_list_c) -#endif - - void *visit(output_declarations_c *symbol) { - TRACE("output_declarations_c"); - current_param_direction = direction_out; - return symbol->var_init_decl_list->accept(*this); - } - void *visit(input_output_declarations_c *symbol) { - TRACE("input_output_declarations_c"); - current_param_direction = direction_inout; - return symbol->var_declaration_list->accept(*this); - } - void *visit(var_declaration_list_c *symbol) {TRACE("var_declaration_list_c"); return iterate_list(symbol);} - -#if 0 -/* var1_list ':' array_specification */ -SYM_REF2(array_var_declaration_c, var1_list, array_specification) - -/* var1_list ':' structure_type_name */ -SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name) -#endif - -/* VAR [CONSTANT] var_init_decl_list END_VAR */ - void *visit(var_declarations_c *symbol) {TRACE("var_declarations_c"); return NULL;} - -#if 0 -/* VAR RETAIN var_init_decl_list END_VAR */ -SYM_REF2(retentive_var_declarations_c, var_init_decl_list, unused) - -/* VAR [CONSTANT|RETAIN|NON_RETAIN] located_var_decl_list END_VAR */ -/* option -> may be NULL ! */ -SYM_REF2(located_var_declarations_c, option, located_var_decl_list) - -/* helper symbol for located_var_declarations */ -/* located_var_decl_list located_var_decl ';' */ -SYM_LIST(located_var_decl_list_c) - -/* [variable_name] location ':' located_var_spec_init */ -/* variable_name -> may be NULL ! */ -SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused) -#endif - -/*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */ -/* option -> may be NULL ! */ -// SYM_REF2(external_var_declarations_c, option, external_declaration_list) - void *visit(external_var_declarations_c *symbol) { - TRACE("external_var_declarations_c"); - current_param_direction = direction_extref; - return symbol->external_declaration_list->accept(*this); - } - -/* helper symbol for external_var_declarations */ -/*| external_declaration_list external_declaration';' */ -// SYM_LIST(external_declaration_list_c) - void *visit(external_declaration_list_c *symbol) {TRACE("external_declaration_list_c"); return iterate_list(symbol);} - -/* global_var_name ':' (simple_specification|subrange_specification|enumerated_specification|array_specification|prev_declared_structure_type_name|function_block_type_name */ -//SYM_REF2(external_declaration_c, global_var_name, specification) - void *visit(external_declaration_c *symbol) { - TRACE("external_declaration_c"); - /* It is OK to store these values in the current_param_XXX - * variables, because if the desired parameter is not in the - * variable list we will be analysing, the current_param_XXXX - * variables will get overwritten when we visit the next - * var1_init_decl_c list! - */ - current_param_default_value = spec_init_sperator_c::get_init(symbol->specification); - current_param_type = spec_init_sperator_c::get_spec(symbol->specification); - - return handle_single_param(symbol->global_var_name); - } - - -#if 0 -/*| VAR_GLOBAL [CONSTANT|RETAIN] global_var_decl_list END_VAR */ -/* option -> may be NULL ! */ -SYM_REF2(global_var_declarations_c, option, global_var_decl_list) - -/* helper symbol for global_var_declarations */ -/*| global_var_decl_list global_var_decl ';' */ -SYM_LIST(global_var_decl_list_c) - -/*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */ -/* type_specification ->may be NULL ! */ -SYM_REF2(global_var_decl_c, global_var_spec, type_specification) - -/*| global_var_name location */ -SYM_REF2(global_var_spec_c, global_var_name, location) - -/* AT direct_variable */ -SYM_REF2(location_c, direct_variable, unused) - -/*| global_var_list ',' global_var_name */ -SYM_LIST(global_var_list_c) - -/* var1_list ':' single_byte_string_spec */ -SYM_REF2(single_byte_string_var_declaration_c, var1_list, single_byte_string_spec) - -/* STRING ['[' integer ']'] [ASSIGN single_byte_character_string] */ -/* integer ->may be NULL ! */ -/* single_byte_character_string ->may be NULL ! */ -SYM_REF2(single_byte_string_spec_c, integer, single_byte_character_string) - -/* var1_list ':' double_byte_string_spec */ -SYM_REF2(double_byte_string_var_declaration_c, var1_list, double_byte_string_spec) - -/* WSTRING ['[' integer ']'] [ASSIGN double_byte_character_string] */ -/* integer ->may be NULL ! */ -/* double_byte_character_string ->may be NULL ! */ -SYM_REF2(double_byte_string_spec_c, integer, double_byte_character_string) - -/*| VAR [RETAIN|NON_RETAIN] incompl_located_var_decl_list END_VAR */ -/* option ->may be NULL ! */ -SYM_REF2(incompl_located_var_declarations_c, option, incompl_located_var_decl_list) - -/* helper symbol for incompl_located_var_declarations */ -/*| incompl_located_var_decl_list incompl_located_var_decl ';' */ -SYM_LIST(incompl_located_var_decl_list_c) - -/* variable_name incompl_location ':' var_spec */ -SYM_REF4(incompl_located_var_decl_c, variable_name, incompl_location, var_spec, unused) - -/* AT incompl_location_token */ -SYM_TOKEN(incompl_location_c) -#endif - - - void *visit(var1_init_decl_c *symbol) { - TRACE("var1_init_decl_c"); - /* It is OK to store these values in the current_param_XXX - * variables, because if the desired parameter is not in the - * variable list we will be analysing, the current_param_XXXX - * variables will get overwritten when we visit the next - * var1_init_decl_c list! - */ - current_param_default_value = spec_init_sperator_c::get_init(symbol->spec_init); - current_param_type = spec_init_sperator_c::get_spec(symbol->spec_init); - - return symbol->var1_list->accept(*this); - } - - - - void *visit(var1_list_c *symbol) { - TRACE("var1_list_c"); - return handle_param_list(symbol); - } - - void *visit(var_init_decl_list_c *symbol) {TRACE("var_init_decl_list_c"); return iterate_list(symbol);} - - -/***********************/ -/* B 1.5.1 - Functions */ -/***********************/ - void *visit(function_declaration_c *symbol) {TRACE("function_declaration_c"); return symbol->var_declarations_list->accept(*this);} - /* intermediate helper symbol for function_declaration */ - void *visit(var_declarations_list_c *symbol) {TRACE("var_declarations_list_c"); return iterate_list(symbol);} - void *visit(function_var_decls_c *symbol) {TRACE("function_var_decls_c"); /* ignore */ return NULL;} - - -/*****************************/ -/* B 1.5.2 - Function Blocks */ -/*****************************/ -/* FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */ - void *visit(function_block_declaration_c *symbol) {TRACE("function_block_declaration_c"); return symbol->var_declarations->accept(*this);} - -/* intermediate helper symbol for function_declaration */ -/* { io_var_declarations | other_var_declarations } */ -/* - * NOTE: we re-use the var_declarations_list_c - */ - -/* VAR_TEMP temp_var_decl_list END_VAR */ - void *visit(temp_var_decls_c *symbol) {TRACE("temp_var_decls_c"); /* ignore */ return NULL;} - void *visit(temp_var_decls_list_c *symbol) {TRACE("temp_var_decls_list_c"); /* ignore */ return NULL;} - -/* VAR NON_RETAIN var_init_decl_list END_VAR */ - void *visit(non_retentive_var_decls_c *symbol) {TRACE("non_retentive_var_decls_c"); /* ignore */ return NULL;} - - -/**********************/ -/* B 1.5.3 - Programs */ -/**********************/ -/* PROGRAM program_type_name program_var_declarations_list function_block_body END_PROGRAM */ -// SYM_REF4(program_declaration_c, program_type_name, var_declarations, function_block_body, unused) - void *visit(program_declaration_c *symbol) {TRACE("program_declaration_c"); return symbol->var_declarations->accept(*this);} - -/* intermediate helper symbol for program_declaration_c */ -/* { io_var_declarations | other_var_declarations } */ -/* - * NOTE: we re-use the var_declarations_list_c - */ - -}; - - - - - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/function_type_decl.h --- a/stage4/generate_cc/function_type_decl.h Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,453 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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 lib - * generated code, do not edit by hand - */ -typedef enum { - function_bool_to_sint, - function_bool_to_int, - function_bool_to_dint, - function_bool_to_lint, - function_bool_to_usint, - function_bool_to_uint, - function_bool_to_udint, - function_bool_to_ulint, - function_bool_to_real, - function_bool_to_lreal, - function_bool_to_time, - function_bool_to_date, - function_bool_to_tod, - function_bool_to_dt, - function_bool_to_string, - function_bool_to_byte, - function_bool_to_word, - function_bool_to_dword, - function_bool_to_lword, - function_sint_to_bool, - function_sint_to_int, - function_sint_to_dint, - function_sint_to_lint, - function_sint_to_usint, - function_sint_to_uint, - function_sint_to_udint, - function_sint_to_ulint, - function_sint_to_real, - function_sint_to_lreal, - function_sint_to_time, - function_sint_to_date, - function_sint_to_tod, - function_sint_to_dt, - function_sint_to_string, - function_sint_to_byte, - function_sint_to_word, - function_sint_to_dword, - function_sint_to_lword, - function_int_to_bool, - function_int_to_sint, - function_int_to_dint, - function_int_to_lint, - function_int_to_usint, - function_int_to_uint, - function_int_to_udint, - function_int_to_ulint, - function_int_to_real, - function_int_to_lreal, - function_int_to_time, - function_int_to_date, - function_int_to_tod, - function_int_to_dt, - function_int_to_string, - function_int_to_byte, - function_int_to_word, - function_int_to_dword, - function_int_to_lword, - function_dint_to_bool, - function_dint_to_sint, - function_dint_to_int, - function_dint_to_lint, - function_dint_to_usint, - function_dint_to_uint, - function_dint_to_udint, - function_dint_to_ulint, - function_dint_to_real, - function_dint_to_lreal, - function_dint_to_time, - function_dint_to_date, - function_dint_to_tod, - function_dint_to_dt, - function_dint_to_string, - function_dint_to_byte, - function_dint_to_word, - function_dint_to_dword, - function_dint_to_lword, - function_lint_to_bool, - function_lint_to_sint, - function_lint_to_int, - function_lint_to_dint, - function_lint_to_usint, - function_lint_to_uint, - function_lint_to_udint, - function_lint_to_ulint, - function_lint_to_real, - function_lint_to_lreal, - function_lint_to_time, - function_lint_to_date, - function_lint_to_tod, - function_lint_to_dt, - function_lint_to_string, - function_lint_to_byte, - function_lint_to_word, - function_lint_to_dword, - function_lint_to_lword, - function_usint_to_bool, - function_usint_to_sint, - function_usint_to_int, - function_usint_to_dint, - function_usint_to_lint, - function_usint_to_uint, - function_usint_to_udint, - function_usint_to_ulint, - function_usint_to_real, - function_usint_to_lreal, - function_usint_to_time, - function_usint_to_date, - function_usint_to_tod, - function_usint_to_dt, - function_usint_to_string, - function_usint_to_byte, - function_usint_to_word, - function_usint_to_dword, - function_usint_to_lword, - function_uint_to_bool, - function_uint_to_sint, - function_uint_to_int, - function_uint_to_dint, - function_uint_to_lint, - function_uint_to_usint, - function_uint_to_udint, - function_uint_to_ulint, - function_uint_to_real, - function_uint_to_lreal, - function_uint_to_time, - function_uint_to_date, - function_uint_to_tod, - function_uint_to_dt, - function_uint_to_string, - function_uint_to_byte, - function_uint_to_word, - function_uint_to_dword, - function_uint_to_lword, - function_udint_to_bool, - function_udint_to_sint, - function_udint_to_int, - function_udint_to_dint, - function_udint_to_lint, - function_udint_to_usint, - function_udint_to_uint, - function_udint_to_ulint, - function_udint_to_real, - function_udint_to_lreal, - function_udint_to_time, - function_udint_to_date, - function_udint_to_tod, - function_udint_to_dt, - function_udint_to_string, - function_udint_to_byte, - function_udint_to_word, - function_udint_to_dword, - function_udint_to_lword, - function_ulint_to_bool, - function_ulint_to_sint, - function_ulint_to_int, - function_ulint_to_dint, - function_ulint_to_lint, - function_ulint_to_usint, - function_ulint_to_uint, - function_ulint_to_udint, - function_ulint_to_real, - function_ulint_to_lreal, - function_ulint_to_time, - function_ulint_to_date, - function_ulint_to_tod, - function_ulint_to_dt, - function_ulint_to_string, - function_ulint_to_byte, - function_ulint_to_word, - function_ulint_to_dword, - function_ulint_to_lword, - function_real_to_bool, - function_real_to_sint, - function_real_to_int, - function_real_to_dint, - function_real_to_lint, - function_real_to_usint, - function_real_to_uint, - function_real_to_udint, - function_real_to_ulint, - function_real_to_lreal, - function_real_to_time, - function_real_to_date, - function_real_to_tod, - function_real_to_dt, - function_real_to_string, - function_real_to_byte, - function_real_to_word, - function_real_to_dword, - function_real_to_lword, - function_lreal_to_bool, - function_lreal_to_sint, - function_lreal_to_int, - function_lreal_to_dint, - function_lreal_to_lint, - function_lreal_to_usint, - function_lreal_to_uint, - function_lreal_to_udint, - function_lreal_to_ulint, - function_lreal_to_real, - function_lreal_to_time, - function_lreal_to_date, - function_lreal_to_tod, - function_lreal_to_dt, - function_lreal_to_string, - function_lreal_to_byte, - function_lreal_to_word, - function_lreal_to_dword, - function_lreal_to_lword, - function_time_to_sint, - function_time_to_int, - function_time_to_dint, - function_time_to_lint, - function_time_to_usint, - function_time_to_uint, - function_time_to_udint, - function_time_to_ulint, - function_time_to_real, - function_time_to_lreal, - function_time_to_string, - function_time_to_byte, - function_time_to_word, - function_time_to_dword, - function_time_to_lword, - function_date_to_sint, - function_date_to_int, - function_date_to_dint, - function_date_to_lint, - function_date_to_usint, - function_date_to_uint, - function_date_to_udint, - function_date_to_ulint, - function_date_to_real, - function_date_to_lreal, - function_date_to_string, - function_date_to_byte, - function_date_to_word, - function_date_to_dword, - function_date_to_lword, - function_tod_to_sint, - function_tod_to_int, - function_tod_to_dint, - function_tod_to_lint, - function_tod_to_usint, - function_tod_to_uint, - function_tod_to_udint, - function_tod_to_ulint, - function_tod_to_real, - function_tod_to_lreal, - function_tod_to_string, - function_tod_to_byte, - function_tod_to_word, - function_tod_to_dword, - function_tod_to_lword, - function_dt_to_sint, - function_dt_to_int, - function_dt_to_dint, - function_dt_to_lint, - function_dt_to_usint, - function_dt_to_uint, - function_dt_to_udint, - function_dt_to_ulint, - function_dt_to_real, - function_dt_to_lreal, - function_dt_to_string, - function_dt_to_byte, - function_dt_to_word, - function_dt_to_dword, - function_dt_to_lword, - function_string_to_bool, - function_string_to_sint, - function_string_to_int, - function_string_to_dint, - function_string_to_lint, - function_string_to_usint, - function_string_to_uint, - function_string_to_udint, - function_string_to_ulint, - function_string_to_real, - function_string_to_lreal, - function_string_to_time, - function_string_to_date, - function_string_to_tod, - function_string_to_dt, - function_string_to_byte, - function_string_to_word, - function_string_to_dword, - function_string_to_lword, - function_byte_to_bool, - function_byte_to_sint, - function_byte_to_int, - function_byte_to_dint, - function_byte_to_lint, - function_byte_to_usint, - function_byte_to_uint, - function_byte_to_udint, - function_byte_to_ulint, - function_byte_to_real, - function_byte_to_lreal, - function_byte_to_time, - function_byte_to_date, - function_byte_to_tod, - function_byte_to_dt, - function_byte_to_string, - function_byte_to_word, - function_byte_to_dword, - function_byte_to_lword, - function_word_to_bool, - function_word_to_sint, - function_word_to_int, - function_word_to_dint, - function_word_to_lint, - function_word_to_usint, - function_word_to_uint, - function_word_to_udint, - function_word_to_ulint, - function_word_to_real, - function_word_to_lreal, - function_word_to_time, - function_word_to_date, - function_word_to_tod, - function_word_to_dt, - function_word_to_string, - function_word_to_byte, - function_word_to_dword, - function_word_to_lword, - function_dword_to_bool, - function_dword_to_sint, - function_dword_to_int, - function_dword_to_dint, - function_dword_to_lint, - function_dword_to_usint, - function_dword_to_uint, - function_dword_to_udint, - function_dword_to_ulint, - function_dword_to_real, - function_dword_to_lreal, - function_dword_to_time, - function_dword_to_date, - function_dword_to_tod, - function_dword_to_dt, - function_dword_to_string, - function_dword_to_byte, - function_dword_to_word, - function_dword_to_lword, - function_lword_to_bool, - function_lword_to_sint, - function_lword_to_int, - function_lword_to_dint, - function_lword_to_lint, - function_lword_to_usint, - function_lword_to_uint, - function_lword_to_udint, - function_lword_to_ulint, - function_lword_to_real, - function_lword_to_lreal, - function_lword_to_time, - function_lword_to_date, - function_lword_to_tod, - function_lword_to_dt, - function_lword_to_string, - function_lword_to_byte, - function_lword_to_word, - function_lword_to_dword, - function_trunc, - function_bcd_to_usint, - function_bcd_to_uint, - function_bcd_to_udint, - function_bcd_to_ulint, - function_usint_to_bcd, - function_uint_to_bcd, - function_udint_to_bcd, - function_ulint_to_bcd, - function_date_and_time_to_time_of_day, - function_date_and_time_to_date, - function_abs, - function_sqrt, - function_ln, - function_log, - function_exp, - function_sin, - function_cos, - function_tan, - function_asin, - function_acos, - function_atan, - function_add, - function_mul, - function_sub, - function_div, - function_mod, - function_expt, - function_move, - function_shl, - function_shr, - function_ror, - function_rol, - function_and, - function_or, - function_xor, - function_not, - function_sel, - function_max, - function_min, - function_limit, - function_mux, - function_gt, - function_ge, - function_eq, - function_lt, - function_le, - function_ne, - function_len, - function_left, - function_right, - function_mid, - function_concat, - function_insert, - function_delete, - function_replace, - function_find, - function_none -} function_type_t; diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/generate_cc.cc --- a/stage4/generate_cc/generate_cc.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1573 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * This is one of the versions available for the 4th stage. - * - * This 4th stage generates a c++ source program equivalent - * to the IL and ST code. - */ - - - - - - -// #include /* required for NULL */ -#include -#include -#include -#include - -#include "../../util/symtable.hh" -#include "../../util/dsymtable.hh" -#include "../../absyntax/visitor.hh" - -#include "../stage4.hh" - - - - - - - - -//#define DEBUG -#ifdef DEBUG -#define TRACE(classname) printf("\n____%s____\n",classname); -#else -#define TRACE(classname) -#endif - - - -#define ERROR error_exit(__FILE__,__LINE__) -/* function defined in main.cc */ -extern void error_exit(const char *file_name, int line_no); - - - - - - - -/* A symbol table with all globally declared functions... */ -function_declaration_c null_symbol1(NULL,NULL,NULL,NULL); -dsymtable_c function_symtable; - -/* A symbol table with all globally declared functions block types... */ -function_block_declaration_c null_symbol2(NULL,NULL,NULL); -symtable_c function_block_type_symtable; - -/* A symbol table with all globally declared program types... */ -program_declaration_c null_symbol3(NULL,NULL,NULL); -symtable_c program_type_symtable; - -/* A symbol table with all user declared type definitions... */ -/* Note that function block types and program types have their - * own symbol tables, so do not get placed in this symbol table! - */ -symbol_c null_symbol4; -symtable_c type_symtable; - - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - - -/* returns 0 if the names are equal!! */ -/* NOTE: it must ignore case!! */ -static int compare_identifiers(symbol_c *ident1, symbol_c *ident2) { - - token_c *name1 = dynamic_cast(ident1); - token_c *name2 = dynamic_cast(ident2); - - if ((name1 == NULL) || (name2 == NULL)) - /* invalid identifiers... */ - return -1; - - if (strcasecmp(name1->value, name2->value) == 0) - return 0; - - /* identifiers do not match! */ - return 1; -} - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - -/* Unlike Programs and Configurations which get mapped onto C++ classes, - * Function Blocks are mapped onto a C structure containing the variables, and - * a C function containing the code in the FB's body. This is to allow direct allocation - * of a FB variable (which is really an instance of the C data structure) to - * a member of a union variable (note that classes with constructors cannot - * be mebers of a union), which is done in IL when loading a FB onto IL's - * default variable. - * - * So as not to clash the names of the C data structure and the C function, - * the C structure is given a name identical to that of the FB name, whereas - * the name of the function is the FB name with a constant string appended. - * The value of that constant string which is appended is defined in the following - * constant. - * In order not to clash with any variable in the IL and ST source codem the - * following constant should contain a double underscore, which is not allowed - * in IL and ST. - * - * e.g.: FUNTION_BLOCK TEST - * is mapped onto a TEST data structure, and a TEST_body__ function. - */ - -#define FB_FUNCTION_SUFFIX "_body__" - -/* Idem as body, but for initializer FB function */ -#define FB_INIT_SUFFIX "_init__" - -/* Idem as body, but for run CONFIG and RESOURCE function */ -#define FB_RUN_SUFFIX "_run__" - -/* The FB body function is passed as the only parameter a pointer to the FB data - * structure instance. The name of this parameter is given by the following constant. - * In order not to clash with any variable in the IL and ST source codem the - * following constant should contain a double underscore, which is not allowed - * in IL and ST. - * - * e.g.: the body of FUNTION_BLOCK TEST - * is mapped onto the C function - * TEST_body__(TEST *data__) - */ - -#define FB_FUNCTION_PARAM "data__" - - -#define SFC_STEP_ACTION_PREFIX "__SFC_" - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - - -#include "spec_init_separator.cc" -#include "function_param_iterator.cc" -#include "function_call_iterator.cc" -#include "function_call_param_iterator.cc" -#include "type_initial_value.cc" -#include "search_fb_instance_decl.cc" -#include "search_base_type.cc" -#include "search_var_instance_decl.cc" -#include "decompose_var_instance_name.cc" -#include "search_varfb_instance_type.cc" -#include "search_constant_type.cc" -#include "search_expression_type.cc" - -#include "generate_cc_base.cc" -#include "generate_cc_typedecl.cc" -#include "generate_cc_sfcdecl.cc" -#include "generate_cc_vardecl.cc" -#include "generate_cc_configbody.cc" -#include "generate_location_list.cc" - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - -/* Generate a name for a temporary variable. - * Each new name generated is appended a different number, - * starting off from 0. - * After calling reset(), the names will start off again from 0. - */ -#define VAR_LEADER "__" -#define TEMP_VAR VAR_LEADER "TMP_" -#define SOURCE_VAR VAR_LEADER "SRC_" - -#include "generate_cc_tempvardecl.cc" - -#include "generate_cc_st.cc" -#include "generate_cc_il.cc" - -#include "generate_cc.hh" - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - -#define MILLISECOND 1000000 -#define SECOND 1000 * MILLISECOND - -/* A helper class that knows how to generate code for both the IL and ST languages... */ -class calculate_time_c: public iterator_visitor_c { - private: - unsigned long time; - float current_value; - - public: - calculate_time_c(void){time = 0;}; - - unsigned long get_time(void) {return time;}; - - void *get_integer_value(token_c *token) { - std::string str = ""; - for (unsigned int i = 0; i < strlen(token->value); i++) - if (token->value[i] != '_') - str += token->value[i]; - current_value = atof(str.c_str()); - return NULL; - } - - void *get_float_value(token_c *token) { - current_value = atof(token->value); - return NULL; - } - -/******************************/ -/* B 1.2.1 - Numeric Literals */ -/******************************/ - - void *visit(integer_c *symbol) {return get_integer_value(symbol);} - -/************************/ -/* B 1.2.3.1 - Duration */ -/************************/ - - /* SYM_REF2(duration_c, neg, interval) */ - void *visit(duration_c *symbol) { - if (symbol->neg != NULL) - ERROR; - symbol->interval->accept(*this); - return NULL; - } - - /* SYM_TOKEN(fixed_point_c) */ - void *visit(fixed_point_c *symbol) {return get_float_value(symbol);} - - /* SYM_REF2(days_c, days, hours) */ - void *visit(days_c *symbol) { - if (symbol->hours) - symbol->hours->accept(*this); - symbol->days->accept(*this); - time += (unsigned long)(current_value * 24 * 3600 * SECOND); - return NULL; - } - - /* SYM_REF2(hours_c, hours, minutes) */ - void *visit(hours_c *symbol) { - if (symbol->minutes) - symbol->minutes->accept(*this); - symbol->hours->accept(*this); - time += (unsigned long)(current_value * 3600 * SECOND); - return NULL; - } - - /* SYM_REF2(minutes_c, minutes, seconds) */ - void *visit(minutes_c *symbol) { - if (symbol->seconds) - symbol->seconds->accept(*this); - symbol->minutes->accept(*this); - time += (unsigned long)(current_value * 60 * SECOND); - return NULL; - } - - /* SYM_REF2(seconds_c, seconds, milliseconds) */ - void *visit(seconds_c *symbol) { - if (symbol->milliseconds) - symbol->milliseconds->accept(*this); - symbol->seconds->accept(*this); - time += (unsigned long)(current_value * SECOND); - return NULL; - } - - /* SYM_REF2(milliseconds_c, milliseconds, unused) */ - void *visit(milliseconds_c *symbol) { - symbol->milliseconds->accept(*this); - time += (unsigned long)(current_value * MILLISECOND); - return NULL; - } -}; - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - -class calculate_common_ticktime_c: public iterator_visitor_c { - private: - unsigned long common_ticktime; - - public: - calculate_common_ticktime_c(void){common_ticktime = 0;} - - unsigned long euclide(unsigned long a, unsigned long b) { - unsigned long c = a % b; - if (c == 0) - return b; - else - return euclide(b, c); - } - - void update_ticktime(unsigned long time) { - if (common_ticktime == 0) - common_ticktime = time; - else if (time > common_ticktime) - common_ticktime = euclide(time, common_ticktime); - else - common_ticktime = euclide(common_ticktime, time); - } - - unsigned long get_ticktime(void) { - return common_ticktime; - } - -/* TASK task_name task_initialization */ -//SYM_REF2(task_configuration_c, task_name, task_initialization) - void *visit(task_initialization_c *symbol) { - calculate_time_c calculate_time; - unsigned long time = 0; - if (symbol->interval_data_source != NULL) { - symbol->interval_data_source->accept(calculate_time); - time = calculate_time.get_time(); - } - if (time > 0) - update_ticktime(time); - return NULL; - } -}; - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - -/* A helper class that knows how to generate code for both the IL and ST languages... */ -class generate_cc_SFC_IL_ST_c: public null_visitor_c { - private: - stage4out_c *s4o_ptr; - symbol_c *scope; - const char *variable_prefix; - - public: - generate_cc_SFC_IL_ST_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL); - /*********************************************/ - /* B.1.6 Sequential function chart elements */ - /*********************************************/ - - /*| sequential_function_chart sfc_network*/ - void *visit(sequential_function_chart_c * symbol); - - /****************************************/ - /* B.2 - Language IL (Instruction List) */ - /****************************************/ - - /***********************************/ - /* B 2.1 Instructions and Operands */ - /***********************************/ - /*| instruction_list il_instruction */ - void *visit(instruction_list_c *symbol); - - /* Remainder implemented in generate_cc_il_c... */ - - /***************************************/ - /* B.3 - Language ST (Structured Text) */ - /***************************************/ - /***********************/ - /* B 3.1 - Expressions */ - /***********************/ - /* Implemented in generate_cc_st_c */ - - /********************/ - /* B 3.2 Statements */ - /********************/ - void *visit(statement_list_c *symbol); - -/* Remainder implemented in generate_cc_st_c... */ -}; - -#include "generate_cc_sfc.cc" - -generate_cc_SFC_IL_ST_c::generate_cc_SFC_IL_ST_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix) { - if (NULL == scope) ERROR; - this->s4o_ptr = s4o_ptr; - this->scope = scope; - this->variable_prefix = variable_prefix; -} - -void *generate_cc_SFC_IL_ST_c::visit(sequential_function_chart_c * symbol) { - generate_cc_sfc_c generate_cc_sfc(s4o_ptr, scope, variable_prefix); - generate_cc_sfc.generate(symbol); - return NULL; -} - -void *generate_cc_SFC_IL_ST_c::visit(instruction_list_c *symbol) { - generate_cc_il_c generate_cc_il(s4o_ptr, scope, variable_prefix); - generate_cc_il.generate(symbol); - return NULL; -} - -void *generate_cc_SFC_IL_ST_c::visit(statement_list_c *symbol) { - generate_cc_st_c generate_cc_st(s4o_ptr, scope, variable_prefix); - generate_cc_st.generate(symbol); - return NULL; -} - - - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - - -class generate_cc_pous_c: public generate_cc_typedecl_c { - - public: - generate_cc_pous_c(stage4out_c *s4o_ptr) - : generate_cc_typedecl_c(s4o_ptr) {}; - virtual ~generate_cc_pous_c(void) {} - - - public: - -/*************************/ -/* B.1 - Common elements */ -/*************************/ -/*******************************************/ -/* B 1.1 - Letters, digits and identifiers */ -/*******************************************/ - /* done in base class(es) */ - -/*********************/ -/* B 1.2 - Constants */ -/*********************/ - /* originally empty... */ - -/******************************/ -/* B 1.2.1 - Numeric Literals */ -/******************************/ - /* done in base class(es) */ - -/*******************************/ -/* B.1.2.2 Character Strings */ -/*******************************/ - /* done in base class(es) */ - -/***************************/ -/* B 1.2.3 - Time Literals */ -/***************************/ -/************************/ -/* B 1.2.3.1 - Duration */ -/************************/ - /* done in base class(es) */ - -/************************************/ -/* B 1.2.3.2 - Time of day and Date */ -/************************************/ - /* done in base class(es) */ - -/**********************/ -/* B.1.3 - Data types */ -/**********************/ -/***********************************/ -/* B 1.3.1 - Elementary Data Types */ -/***********************************/ - /* done in base class(es) */ - -/********************************/ -/* B.1.3.2 - Generic data types */ -/********************************/ - /* originally empty... */ - -/********************************/ -/* B 1.3.3 - Derived data types */ -/********************************/ - /* done in base class(es) */ - -/*********************/ -/* B 1.4 - Variables */ -/*********************/ - /* done in base class(es) */ - -/********************************************/ -/* B.1.4.1 Directly Represented Variables */ -/********************************************/ - /* done in base class(es) */ - -/*************************************/ -/* B.1.4.2 Multi-element Variables */ -/*************************************/ - /* done in base class(es) */ - -/******************************************/ -/* B 1.4.3 - Declaration & Initialisation */ -/******************************************/ - /* done in base class(es) */ - -/**************************************/ -/* B.1.5 - Program organization units */ -/**************************************/ -/***********************/ -/* B 1.5.1 - Functions */ -/***********************/ - -public: -/* FUNCTION derived_function_name ':' elementary_type_name io_OR_function_var_declarations_list function_body END_FUNCTION */ -/* | FUNCTION derived_function_name ':' derived_type_name io_OR_function_var_declarations_list function_body END_FUNCTION */ -void *visit(function_declaration_c *symbol) { - generate_cc_vardecl_c *vardecl; - TRACE("function_declaration_c"); - - /* start off by adding this declaration to the global - * function declaration symbol table... - */ - function_symtable.insert(symbol->derived_function_name, symbol); - - /* (A) Function declaration... */ - /* (A.1) Function return type */ - s4o.print("// FUNCTION\n"); - symbol->type_name->accept(*this); /* return type */ - s4o.print(" "); - /* (A.2) Function name */ - symbol->derived_function_name->accept(*this); - s4o.print("("); - - /* (A.3) Function parameters */ - s4o.indent_right(); - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::finterface_vf, - generate_cc_vardecl_c::input_vt | - generate_cc_vardecl_c::output_vt | - generate_cc_vardecl_c::inoutput_vt); - vardecl->print(symbol->var_declarations_list); - delete vardecl; - s4o.indent_left(); - - s4o.print(")\n" + s4o.indent_spaces + "{\n"); - - /* (B) Function local variable declaration */ - /* (B.1) Variables declared in ST source code */ - s4o.indent_right(); - vardecl = new generate_cc_vardecl_c(&s4o, generate_cc_vardecl_c::localinit_vf, generate_cc_vardecl_c::private_vt); - vardecl->print(symbol->var_declarations_list); - delete vardecl; - - /* (B.2) Temporary variable for function's return value */ - /* It will have the same name as the function itself! */ - s4o.print(s4o.indent_spaces); - symbol->type_name->accept(*this); /* return type */ - s4o.print(" "); - symbol->derived_function_name->accept(*this); - s4o.print(" = "); - { - /* get the default value of this variable's type */ - symbol_c *default_value = (symbol_c *)symbol->type_name->accept(*type_initial_value_c::instance()); - if (default_value == NULL) ERROR; - default_value->accept(*this); - } - s4o.print(";\n\n"); - - /* (C) Function body */ - generate_cc_SFC_IL_ST_c generate_cc_code(&s4o, symbol); - symbol->function_body->accept(generate_cc_code); - s4o.print(s4o.indent_spaces + "return "); - symbol->derived_function_name->accept(*this); - s4o.print(";\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n\n\n"); - - return NULL; -} - - -/* The remaining var_declarations_list_c, function_var_decls_c - * and var2_init_decl_list_c are handled in the generate_cc_vardecl_c class - */ - - -/*****************************/ -/* B 1.5.2 - Function Blocks */ -/*****************************/ -public: -/* FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */ -//SYM_REF4(function_block_declaration_c, fblock_name, var_declarations, fblock_body, unused) -void *visit(function_block_declaration_c *symbol) { - generate_cc_vardecl_c *vardecl; - generate_cc_sfcdecl_c *sfcdecl; - TRACE("function_block_declaration_c"); - - /* start off by adding this declaration to the global - * function block declaration symbol table... - */ - function_block_type_symtable.insert(symbol->fblock_name, symbol); - - /* (A) Function Block data structure declaration... */ - /* (A.1) Data structure declaration */ - s4o.print("// FUNCTION_BLOCK "); - symbol->fblock_name->accept(*this); - s4o.print("\n// Data part\n"); - s4o.print("typedef struct {\n"); - s4o.indent_right(); - /* (A.2) Public variables: i.e. the function parameters... */ - s4o.print(s4o.indent_spaces + "// FB Interface - IN, OUT, IN_OUT variables\n"); - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::local_vf, - generate_cc_vardecl_c::input_vt | - generate_cc_vardecl_c::output_vt | - generate_cc_vardecl_c::inoutput_vt); - vardecl->print(symbol->var_declarations); - delete vardecl; - s4o.print("\n"); - /* (A.3) Private internal variables */ - s4o.print(s4o.indent_spaces + "// FB private variables - TEMP, private and located variables\n"); - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::local_vf, - generate_cc_vardecl_c::temp_vt | - generate_cc_vardecl_c::private_vt | - generate_cc_vardecl_c::located_vt | - generate_cc_vardecl_c::external_vt); - vardecl->print(symbol->var_declarations); - delete vardecl; - /* (A.4) Generate private internal variables for SFC */ - sfcdecl = new generate_cc_sfcdecl_c(&s4o, generate_cc_sfcdecl_c::sfcdecl_sd); - sfcdecl->print(symbol->fblock_body); - delete sfcdecl; - s4o.print("\n"); - - /* (A.5) Function Block data structure type name. */ - s4o.indent_left(); - s4o.print("} "); - symbol->fblock_name->accept(*this); - s4o.print(";\n\n"); - - - /* (B) Constructor */ - /* (B.1) Constructor name... */ - s4o.print(s4o.indent_spaces + "void "); - symbol->fblock_name->accept(*this); - s4o.print(FB_INIT_SUFFIX); - s4o.print("("); - - /* first and only parameter is a pointer to the data */ - symbol->fblock_name->accept(*this); - s4o.print(" *"); - s4o.print(FB_FUNCTION_PARAM); - s4o.print(") {\n"); - s4o.indent_right(); - - /* (B.2) Member initializations... */ - s4o.print(s4o.indent_spaces); - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::constructorinit_vf, - generate_cc_vardecl_c::input_vt | - generate_cc_vardecl_c::output_vt | - generate_cc_vardecl_c::inoutput_vt | - generate_cc_vardecl_c::private_vt | - generate_cc_vardecl_c::located_vt | - generate_cc_vardecl_c::external_vt); - vardecl->print(symbol->var_declarations, NULL, FB_FUNCTION_PARAM"->"); - delete vardecl; - s4o.print("\n"); - /* (B.3) Generate private internal variables for SFC */ - sfcdecl = new generate_cc_sfcdecl_c(&s4o, generate_cc_sfcdecl_c::sfcinit_sd); - sfcdecl->print(symbol->fblock_body, FB_FUNCTION_PARAM"->"); - delete sfcdecl; - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n\n"); - - - /* (C) Function with FB body */ - /* (C.1) Step definitions */ - sfcdecl = new generate_cc_sfcdecl_c(&s4o, generate_cc_sfcdecl_c::stepdef_sd); - sfcdecl->print(symbol->fblock_body); - delete sfcdecl; - - /* (C.2) Action definitions */ - sfcdecl = new generate_cc_sfcdecl_c(&s4o, generate_cc_sfcdecl_c::actiondef_sd); - sfcdecl->print(symbol->fblock_body); - delete sfcdecl; - - /* (C.3) Function declaration */ - s4o.print("// Code part\n"); - /* function interface */ - s4o.print("void "); - symbol->fblock_name->accept(*this); - s4o.print(FB_FUNCTION_SUFFIX); - s4o.print("("); - /* first and only parameter is a pointer to the data */ - symbol->fblock_name->accept(*this); - s4o.print(" *"); - s4o.print(FB_FUNCTION_PARAM); - s4o.print(") {\n"); - s4o.indent_right(); - - /* (C.4) Initialize TEMP variables */ - /* function body */ - s4o.print(s4o.indent_spaces + "// Initialise TEMP variables\n"); - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::init_vf, - generate_cc_vardecl_c::temp_vt); - vardecl->print(symbol->var_declarations, NULL, FB_FUNCTION_PARAM"->"); - delete vardecl; - s4o.print("\n"); - - /* (C.5) Function code */ - generate_cc_SFC_IL_ST_c generate_cc_code(&s4o, symbol, FB_FUNCTION_PARAM"->"); - symbol->fblock_body->accept(generate_cc_code); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "} // "); - symbol->fblock_name->accept(*this); - s4o.print(FB_FUNCTION_SUFFIX); - s4o.print(s4o.indent_spaces + "() \n\n"); - - /* (C.6) Step undefinitions */ - sfcdecl = new generate_cc_sfcdecl_c(&s4o, generate_cc_sfcdecl_c::stepundef_sd); - sfcdecl->print(symbol->fblock_body); - delete sfcdecl; - - /* (C.7) Action undefinitions */ - sfcdecl = new generate_cc_sfcdecl_c(&s4o, generate_cc_sfcdecl_c::actionundef_sd); - sfcdecl->print(symbol->fblock_body); - delete sfcdecl; - - s4o.indent_left(); - s4o.print("\n\n\n\n"); - - return NULL; -} - - -/* The remaining temp_var_decls_c, temp_var_decls_list_c - * and non_retentive_var_decls_c are handled in the generate_cc_vardecl_c class - */ - - -/**********************/ -/* B 1.5.3 - Programs */ -/**********************/ - - - -public: -/* PROGRAM program_type_name program_var_declarations_list function_block_body END_PROGRAM */ -//SYM_REF4(program_declaration_c, program_type_name, var_declarations, function_block_body, unused) -void *visit(program_declaration_c *symbol) { - generate_cc_vardecl_c *vardecl; - generate_cc_sfcdecl_c *sfcdecl; - TRACE("program_declaration_c"); - - /* start off by adding this declaration to the global - * program declaration symbol table... - */ - program_type_symtable.insert(symbol->program_type_name, symbol); - - /* (A) Program data structure declaration... */ - /* (A.1) Data structure declaration */ - s4o.print("// PROGRAM "); - symbol->program_type_name->accept(*this); - s4o.print("\n// Data part\n"); - s4o.print("typedef struct {\n"); - s4o.indent_right(); - - /* (A.2) Public variables: i.e. the program parameters... */ - s4o.print(s4o.indent_spaces + "// PROGRAM Interface - IN, OUT, IN_OUT variables\n"); - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::local_vf, - generate_cc_vardecl_c::input_vt | - generate_cc_vardecl_c::output_vt | - generate_cc_vardecl_c::inoutput_vt); - vardecl->print(symbol->var_declarations); - delete vardecl; - s4o.print("\n"); - /* (A.3) Private internal variables */ - s4o.print(s4o.indent_spaces + "// PROGRAM private variables - TEMP, private and located variables\n"); - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::local_vf, - generate_cc_vardecl_c::temp_vt | - generate_cc_vardecl_c::private_vt | - generate_cc_vardecl_c::located_vt | - generate_cc_vardecl_c::external_vt); - vardecl->print(symbol->var_declarations); - delete vardecl; - /* (A.4) Generate private internal variables for SFC */ - sfcdecl = new generate_cc_sfcdecl_c(&s4o, generate_cc_sfcdecl_c::sfcdecl_sd); - sfcdecl->print(symbol->function_block_body); - delete sfcdecl; - - /* (A.5) Program data structure type name. */ - s4o.indent_left(); - s4o.print("} "); - symbol->program_type_name->accept(*this); - s4o.print(";\n\n"); - - /* (B) Constructor */ - /* (B.1) Constructor name... */ - s4o.print(s4o.indent_spaces + "void "); - symbol->program_type_name->accept(*this); - s4o.print(FB_INIT_SUFFIX); - s4o.print("("); - - /* first and only parameter is a pointer to the data */ - symbol->program_type_name->accept(*this); - s4o.print(" *"); - s4o.print(FB_FUNCTION_PARAM); - s4o.print(") {\n"); - s4o.indent_right(); - - /* (B.2) Member initializations... */ - s4o.print(s4o.indent_spaces); - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::constructorinit_vf, - generate_cc_vardecl_c::input_vt | - generate_cc_vardecl_c::output_vt | - generate_cc_vardecl_c::inoutput_vt | - generate_cc_vardecl_c::private_vt | - generate_cc_vardecl_c::located_vt | - generate_cc_vardecl_c::external_vt); - vardecl->print(symbol->var_declarations, NULL, FB_FUNCTION_PARAM"->"); - delete vardecl; - s4o.print("\n"); - /* (B.3) Generate private internal variables for SFC */ - sfcdecl = new generate_cc_sfcdecl_c(&s4o, generate_cc_sfcdecl_c::sfcinit_sd); - sfcdecl->print(symbol->function_block_body,FB_FUNCTION_PARAM"->"); - delete sfcdecl; - - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n\n"); - - /* (C) Function with PROGRAM body */ - /* (C.1) Step definitions */ - sfcdecl = new generate_cc_sfcdecl_c(&s4o, generate_cc_sfcdecl_c::stepdef_sd); - sfcdecl->print(symbol->function_block_body); - delete sfcdecl; - - /* (C.2) Action definitions */ - sfcdecl = new generate_cc_sfcdecl_c(&s4o, generate_cc_sfcdecl_c::actiondef_sd); - sfcdecl->print(symbol->function_block_body); - delete sfcdecl; - - /* (C.3) Function declaration */ - s4o.print("// Code part\n"); - /* function interface */ - s4o.print("void "); - symbol->program_type_name->accept(*this); - s4o.print(FB_FUNCTION_SUFFIX); - s4o.print("("); - /* first and only parameter is a pointer to the data */ - symbol->program_type_name->accept(*this); - s4o.print(" *"); - s4o.print(FB_FUNCTION_PARAM); - s4o.print(") {\n"); - s4o.indent_right(); - - /* (C.4) Initialize TEMP variables */ - /* function body */ - s4o.print(s4o.indent_spaces + "// Initialise TEMP variables\n"); - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::init_vf, - generate_cc_vardecl_c::temp_vt); - vardecl->print(symbol->var_declarations, NULL, FB_FUNCTION_PARAM"->"); - delete vardecl; - s4o.print("\n"); - - /* (C.5) Function code */ - generate_cc_SFC_IL_ST_c generate_cc_code(&s4o, symbol, FB_FUNCTION_PARAM"->"); - symbol->function_block_body->accept(generate_cc_code); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "} // "); - symbol->program_type_name->accept(*this); - s4o.print(FB_FUNCTION_SUFFIX); - s4o.print(s4o.indent_spaces + "() \n\n"); - - /* (C.6) Step undefinitions */ - sfcdecl = new generate_cc_sfcdecl_c(&s4o, generate_cc_sfcdecl_c::stepundef_sd); - sfcdecl->print(symbol->function_block_body); - delete sfcdecl; - - /* (C.7) Action undefinitions */ - sfcdecl = new generate_cc_sfcdecl_c(&s4o, generate_cc_sfcdecl_c::actionundef_sd); - sfcdecl->print(symbol->function_block_body); - delete sfcdecl; - - s4o.indent_left(); - s4o.print("\n\n\n\n"); - - return NULL; -} - -}; /* generate_cc_pous_c */ - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - -class generate_cc_config_c: public generate_cc_typedecl_c { - - public: - generate_cc_config_c(stage4out_c *s4o_ptr) - : generate_cc_typedecl_c(s4o_ptr) {}; - virtual ~generate_cc_config_c(void) {} - - typedef enum { - initprotos_dt, - initdeclare_dt, - runprotos_dt, - rundeclare_dt - } declaretype_t; - - declaretype_t wanted_declaretype; - -/********************************/ -/* B 1.7 Configuration elements */ -/********************************/ - - -public: -/* -CONFIGURATION configuration_name - optional_global_var_declarations - (resource_declaration_list | single_resource_declaration) - optional_access_declarations - optional_instance_specific_initializations -END_CONFIGURATION -*/ -/* -SYM_REF6(configuration_declaration_c, configuration_name, global_var_declarations, resource_declarations, access_declarations, instance_specific_initializations, unused) -*/ -void *visit(configuration_declaration_c *symbol) { - generate_cc_vardecl_c *vardecl; - - /* Insert the header... */ - s4o.print("/*******************************************/\n"); - s4o.print("/* FILE GENERATED BY iec2cc */\n"); - s4o.print("/* Editing this file is not recommended... */\n"); - s4o.print("/*******************************************/\n\n"); - s4o.print("#include \"iec_std_lib.h\"\n\n"); - - /* (A) configuration declaration... */ - /* (A.1) configuration name in comment */ - s4o.print("// CONFIGURATION "); - symbol->configuration_name->accept(*this); - s4o.print("\n"); - - /* (A.2) Global variables */ - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::local_vf, - generate_cc_vardecl_c::global_vt); - vardecl->print(symbol); - delete vardecl; - s4o.print("\n"); - - /* (B) Initialisation Function */ - /* (B.1) Ressources initialisation protos... */ - wanted_declaretype = initprotos_dt; - symbol->resource_declarations->accept(*this); - s4o.print("\n"); - - /* (B.2) Initialisation function name... */ - s4o.print(s4o.indent_spaces + "void config"); - s4o.print(FB_INIT_SUFFIX); - s4o.print("(void) {\n"); - s4o.indent_right(); - - /* (B.3) Global variables initializations... */ - s4o.print(s4o.indent_spaces); - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::constructorinit_vf, - generate_cc_vardecl_c::global_vt); - vardecl->print(symbol); - delete vardecl; - s4o.print("\n"); - - /* (B.3) Resources initializations... */ - wanted_declaretype = initdeclare_dt; - symbol->resource_declarations->accept(*this); - - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n\n"); - - - /* (C) Run Function*/ - /* (C.1) Resources run functions protos... */ - wanted_declaretype = runprotos_dt; - symbol->resource_declarations->accept(*this); - s4o.print("\n"); - - /* (C.2) Run function name... */ - s4o.print(s4o.indent_spaces + "void config"); - s4o.print(FB_RUN_SUFFIX); - s4o.print("(int tick) {\n"); - s4o.indent_right(); - - /* (C.3) Resources initializations... */ - wanted_declaretype = rundeclare_dt; - symbol->resource_declarations->accept(*this); - - /* (C.3) Close Public Function body */ - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - - return NULL; -} - -void *visit(resource_declaration_c *symbol) { - if (wanted_declaretype == initprotos_dt || wanted_declaretype == runprotos_dt) { - s4o.print(s4o.indent_spaces + "void "); - symbol->resource_name->accept(*this); - if (wanted_declaretype == initprotos_dt) { - s4o.print(FB_INIT_SUFFIX); - s4o.print("(void);\n"); - } - else { - s4o.print(FB_RUN_SUFFIX); - s4o.print("(int tick);\n"); - } - } - if (wanted_declaretype == initdeclare_dt || wanted_declaretype == rundeclare_dt) { - s4o.print(s4o.indent_spaces); - symbol->resource_name->accept(*this); - if (wanted_declaretype == initdeclare_dt) { - s4o.print(FB_INIT_SUFFIX); - s4o.print("();\n"); - } - else { - s4o.print(FB_RUN_SUFFIX); - s4o.print("(tick);\n"); - } - } - return NULL; -} - -void *visit(single_resource_declaration_c *symbol) { - if (wanted_declaretype == initprotos_dt || wanted_declaretype == runprotos_dt) { - s4o.print(s4o.indent_spaces + "void RESOURCE"); - if (wanted_declaretype == initprotos_dt) { - s4o.print(FB_INIT_SUFFIX); - s4o.print("(void);\n"); - } - else { - s4o.print(FB_RUN_SUFFIX); - s4o.print("(int tick);\n"); - } - } - if (wanted_declaretype == initdeclare_dt || wanted_declaretype == rundeclare_dt) { - s4o.print(s4o.indent_spaces + "RESOURCE"); - if (wanted_declaretype == initdeclare_dt) { - s4o.print(FB_INIT_SUFFIX); - s4o.print("();\n"); - } - else { - s4o.print(FB_RUN_SUFFIX); - s4o.print("(tick);\n"); - } - } - return NULL; -} - -}; - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - - -class generate_cc_resources_c: public generate_cc_typedecl_c { - - search_var_instance_decl_c *search_config_instance; - search_var_instance_decl_c *search_resource_instance; - - private: - /* The name of the resource curretnly being processed... */ - symbol_c *current_resource_name; - symbol_c *current_global_vars; - - public: - generate_cc_resources_c(stage4out_c *s4o_ptr, symbol_c *config_scope, symbol_c *resource_scope, unsigned long time) - : generate_cc_typedecl_c(s4o_ptr) { - search_config_instance = new search_var_instance_decl_c(config_scope); - search_resource_instance = new search_var_instance_decl_c(resource_scope); - common_ticktime = time; - current_resource_name = NULL; - current_global_vars = NULL; - }; - virtual ~generate_cc_resources_c(void) { - delete search_config_instance; - delete search_resource_instance; - } - - typedef enum { - declare_dt, - init_dt, - run_dt - } declaretype_t; - - declaretype_t wanted_declaretype; - - unsigned long common_ticktime; - - const char *current_program_name; - - typedef enum { - assign_at, - send_at - } assigntype_t; - - assigntype_t wanted_assigntype; - -/********************************/ -/* B 1.7 Configuration elements */ -/********************************/ - -/* -RESOURCE resource_name ON resource_type_name - optional_global_var_declarations - single_resource_declaration -END_RESOURCE -*/ -// SYM_REF4(resource_declaration_c, resource_name, resource_type_name, global_var_declarations, resource_declaration) - void *visit(resource_declaration_c *symbol) { - current_resource_name = symbol->resource_name; - current_global_vars = symbol->global_var_declarations; - - symbol->resource_declaration->accept(*this); - - current_resource_name = NULL; - current_global_vars = NULL; - return NULL; - } - -/* task_configuration_list program_configuration_list */ -// SYM_REF2(single_resource_declaration_c, task_configuration_list, program_configuration_list) - void *visit(single_resource_declaration_c *symbol) { - bool single_resource = current_resource_name == NULL; - if (single_resource) - current_resource_name = new identifier_c("RESOURCE"); - generate_cc_vardecl_c *vardecl; - - /* Insert the header... */ - s4o.print("/*******************************************/\n"); - s4o.print("/* FILE GENERATED BY iec2cc */\n"); - s4o.print("/* Editing this file is not recommended... */\n"); - s4o.print("/*******************************************/\n\n"); - s4o.print("#include \"iec_std_lib.h\"\n\n"); - - /* (A) resource declaration... */ - /* (A.1) resource name in comment */ - s4o.print("// RESOURCE "); - current_resource_name->accept(*this); - s4o.print("\n"); - - /* (A.2) Global variables... */ - if (current_global_vars != NULL) { - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::local_vf, - generate_cc_vardecl_c::global_vt); - vardecl->print(current_global_vars); - delete vardecl; - } - s4o.print("\n"); - - /* (A.3) POUs inclusion */ - s4o.print("#include \"POUS.c\"\n\n"); - - /* (A.4) Resource programs declaration... */ - wanted_declaretype = declare_dt; - symbol->program_configuration_list->accept(*this); - s4o.print("\n"); - - /* (B) resource initialisation function... */ - /* (B.1) initialisation function name... */ - s4o.print("void "); - current_resource_name->accept(*this); - s4o.print(FB_INIT_SUFFIX); - s4o.print("(void) {\n"); - s4o.indent_right(); - - /* (B.2) Global variables initialisations... */ - if (current_global_vars != NULL) { - s4o.print(s4o.indent_spaces); - vardecl = new generate_cc_vardecl_c(&s4o, - generate_cc_vardecl_c::constructorinit_vf, - generate_cc_vardecl_c::global_vt); - vardecl->print(current_global_vars); - delete vardecl; - } - s4o.print("\n"); - - /* (B.3) Resource programs initialisations... */ - wanted_declaretype = init_dt; - symbol->program_configuration_list->accept(*this); - - s4o.indent_left(); - s4o.print("}\n\n"); - - /* (C) Resource run function... */ - /* (C.1) Run function name... */ - s4o.print("void "); - current_resource_name->accept(*this); - s4o.print(FB_RUN_SUFFIX); - s4o.print("(int tick) {\n"); - s4o.indent_right(); - - /* (C.2) Task management... */ - symbol->task_configuration_list->accept(*this); - - /* (C.3) Program run declaration... */ - wanted_declaretype = run_dt; - symbol->program_configuration_list->accept(*this); - - s4o.indent_left(); - s4o.print("}\n\n"); - - if (single_resource) { - delete current_resource_name; - current_resource_name = NULL; - } - return NULL; - } - -/* PROGRAM [RETAIN | NON_RETAIN] program_name [WITH task_name] ':' program_type_name ['(' prog_conf_elements ')'] */ -//SYM_REF6(program_configuration_c, retain_option, program_name, task_name, program_type_name, prog_conf_elements, unused) - void *visit(program_configuration_c *symbol) { - if (wanted_declaretype == declare_dt) { - s4o.print(s4o.indent_spaces); - symbol->program_type_name->accept(*this); - s4o.print(" "); - symbol->program_name->accept(*this); - s4o.print(";\n"); - } - if (wanted_declaretype == init_dt) { - s4o.print(s4o.indent_spaces); - symbol->program_type_name->accept(*this); - s4o.print(FB_INIT_SUFFIX); - s4o.print("(&"); - symbol->program_name->accept(*this); - s4o.print(");\n"); - } - if (wanted_declaretype == run_dt) { - current_program_name = ((identifier_c*)(symbol->program_name))->value; - if (symbol->task_name != NULL) { - s4o.print(s4o.indent_spaces); - s4o.print("if ("); - symbol->task_name->accept(*this); - s4o.print(" == 0) {\n"); - s4o.indent_right(); - } - - wanted_assigntype = assign_at; - if (symbol->prog_conf_elements != NULL) - symbol->prog_conf_elements->accept(*this); - - s4o.print(s4o.indent_spaces); - symbol->program_type_name->accept(*this); - s4o.print(FB_FUNCTION_SUFFIX); - s4o.print("(&"); - symbol->program_name->accept(*this); - s4o.print(");\n"); - - wanted_assigntype = send_at; - if (symbol->prog_conf_elements != NULL) - symbol->prog_conf_elements->accept(*this); - - if (symbol->task_name != NULL) { - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - } - } - return NULL; - } - -/* TASK task_name task_initialization */ -//SYM_REF2(task_configuration_c, task_name, task_initialization) - void *visit(task_configuration_c *symbol) { - s4o.print(s4o.indent_spaces + "int "); - symbol->task_name->accept(*this); - s4o.print(" = "); - symbol->task_initialization->accept(*this); - s4o.print(";\n"); - return NULL; - } - -/* '(' [SINGLE ASSIGN data_source ','] [INTERVAL ASSIGN data_source ','] PRIORITY ASSIGN integer ')' */ -//SYM_REF4(task_initialization_c, single_data_source, interval_data_source, priority_data_source, unused) - void *visit(task_initialization_c *symbol) { - if (symbol->interval_data_source != NULL) { - calculate_time_c calculate_time; - symbol->interval_data_source->accept(calculate_time); - unsigned long time = calculate_time.get_time(); - if (time != 0) { - s4o.print("tick % "); - s4o.print_integer((int)(time / common_ticktime)); - } - else - s4o.print("1"); - } - else - s4o.print("1"); - return NULL; - } - -/* any_symbolic_variable ASSIGN prog_data_source */ -//SYM_REF2(prog_cnxn_assign_c, symbolic_variable, prog_data_source) - void *visit(prog_cnxn_assign_c *symbol) { - if (wanted_assigntype == assign_at) { - symbol_c *var_decl; - unsigned int vartype = 0; - symbol_c *current_var_reference = ((global_var_reference_c *)(symbol->prog_data_source))->global_var_name; - var_decl = search_resource_instance->get_decl(current_var_reference); - if (var_decl == NULL) { - var_decl = search_config_instance->get_decl(current_var_reference); - if (var_decl == NULL) - ERROR; - else - vartype = search_config_instance->get_vartype(); - } - else - vartype = search_resource_instance->get_vartype(); - - s4o.print(s4o.indent_spaces + "{extern "); - var_decl->accept(*this); - s4o.print(" "); - symbol->prog_data_source->accept(*this); - s4o.print("; "); - s4o.print(current_program_name); - s4o.print("."); - symbol->symbolic_variable->accept(*this); - s4o.print(" = "); - if (vartype || search_var_instance_decl_c::global_vt) - s4o.print("*"); - symbol->prog_data_source->accept(*this); - s4o.print(";}\n"); - } - return NULL; - } - -/* any_symbolic_variable SENDTO data_sink */ -//SYM_REF2(prog_cnxn_sendto_c, symbolic_variable, data_sink) - void *visit(prog_cnxn_sendto_c *symbol) { - if (wanted_assigntype == send_at) { - symbol_c *var_decl; - unsigned int vartype = 0; - symbol_c *current_var_reference = ((global_var_reference_c *)(symbol->data_sink))->global_var_name; - var_decl = search_resource_instance->get_decl(current_var_reference); - if (var_decl == NULL) { - var_decl = search_config_instance->get_decl(current_var_reference); - if (var_decl == NULL) - ERROR; - else - vartype = search_config_instance->get_vartype(); - } - else - vartype = search_resource_instance->get_vartype(); - - s4o.print(s4o.indent_spaces); - s4o.print(s4o.indent_spaces + "{extern "); - var_decl->accept(*this); - s4o.print(" "); - symbol->data_sink->accept(*this); - s4o.print("; "); - if (vartype || search_var_instance_decl_c::global_vt) - s4o.print("*"); - symbol->data_sink->accept(*this); - s4o.print(" = "); - s4o.print(current_program_name); - s4o.print("."); - symbol->symbolic_variable->accept(*this); - s4o.print("};\n"); - } - return NULL; - } - -}; - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - -class generate_cc_c: public iterator_visitor_c { - protected: - stage4out_c &s4o; - stage4out_c pous_s4o; - stage4out_c located_variables_s4o; - generate_cc_pous_c generate_cc_pous; - - symbol_c *current_configuration; - - const char *current_name; - const char *current_builddir; - - unsigned long common_ticktime; - - public: - generate_cc_c(stage4out_c *s4o_ptr, const char *builddir): - s4o(*s4o_ptr), - pous_s4o(builddir, "POUS", "c"), - located_variables_s4o(builddir, "LOCATED_VARIABLES","h"), - generate_cc_pous(&pous_s4o) { - current_builddir = builddir; - current_configuration = NULL; - } - - ~generate_cc_c(void) {} - -/***************************/ -/* B 0 - Programming Model */ -/***************************/ - void *visit(library_c *symbol) { - generate_location_list_c generate_location_list(&located_variables_s4o); - symbol->accept(generate_location_list); - - for(int i = 0; i < symbol->n; i++) { - symbol->elements[i]->accept(*this); - } - return NULL; - } - -/*************************/ -/* B.1 - Common elements */ -/*************************/ -/*******************************************/ -/* B 1.1 - Letters, digits and identifiers */ -/*******************************************/ - void *visit(identifier_c *symbol) { - current_name = symbol->value; - return NULL; - } - -/**************************************/ -/* B.1.5 - Program organization units */ -/**************************************/ -/***********************/ -/* B 1.5.1 - Functions */ -/***********************/ - void *visit(function_declaration_c *symbol) { - symbol->accept(generate_cc_pous); - return NULL; - } - -/*****************************/ -/* B 1.5.2 - Function Blocks */ -/*****************************/ - void *visit(function_block_declaration_c *symbol) { - symbol->accept(generate_cc_pous); - return NULL; - } - -/**********************/ -/* B 1.5.3 - Programs */ -/**********************/ - void *visit(program_declaration_c *symbol) { - symbol->accept(generate_cc_pous); - return NULL; - } - - -/********************************/ -/* B 1.7 Configuration elements */ -/********************************/ - void *visit(configuration_declaration_c *symbol) { - static int configuration_count = 0; - - if (configuration_count++) { - /* the first configuration is the one we will use!! */ - ERROR; - } - - current_configuration = symbol; - - calculate_common_ticktime_c calculate_common_ticktime; - symbol->accept(calculate_common_ticktime); - common_ticktime = calculate_common_ticktime.get_ticktime(); - - symbol->configuration_name->accept(*this); - stage4out_c config_s4o(current_builddir, current_name, "c"); - generate_cc_config_c generate_cc_config(&config_s4o); - symbol->accept(generate_cc_config); - - config_s4o.print("int common_ticktime__ = "); - config_s4o.print_integer((int)(common_ticktime / 1000000)); - config_s4o.print("; /*ms*/\n"); - - symbol->resource_declarations->accept(*this); - - current_configuration = NULL; - - return NULL; - } - - void *visit(resource_declaration_c *symbol) { - symbol->resource_name->accept(*this); - stage4out_c resources_s4o(current_builddir, current_name, "c"); - generate_cc_resources_c generate_cc_resources(&resources_s4o, current_configuration, symbol, common_ticktime); - symbol->accept(generate_cc_resources); - return NULL; - } - - void *visit(single_resource_declaration_c *symbol) { - stage4out_c resources_s4o(current_builddir, "RESOURCE", "c"); - generate_cc_resources_c generate_cc_resources(&resources_s4o, current_configuration, symbol, common_ticktime); - symbol->accept(generate_cc_resources); - return NULL; - } - -}; - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - - - - -visitor_c *new_code_generator(stage4out_c *s4o, const char *builddir) {return new generate_cc_c(s4o, builddir);} -void delete_code_generator(visitor_c *code_generator) {delete code_generator;} - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/generate_cc.hh --- a/stage4/generate_cc/generate_cc.hh Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,56 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * This is one of the versions available for the 4th stage. - * - * This 4th stage generates a c++ source program equivalent - * to the IL and ST code. - */ - - -/* - * generate_cc.HH - */ - - -#ifndef _generate_cc_HH -#define _generate_cc_HH - - - -#include -#include "../../absyntax/absyntax.hh" -#include "../../absyntax/visitor.hh" - - - - - - - - -#endif /* _generate_cc_HH */ - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/generate_cc_base.cc --- a/stage4/generate_cc/generate_cc_base.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,668 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * Conversion of basic abstract syntax constructs. - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the IL and ST - * code. - */ - - - - - - -//#include /* required for NULL */ -//#include -//#include - -//#include "../../util/symtable.hh" - -//#include "generate_cc.hh" - - - - - - - - - - - - - -class generate_cc_base_c: public iterator_visitor_c { - - protected: - stage4out_c &s4o; - - private: - /* Unlike programs that are mapped onto C++ classes, Function Blocks are mapped onto a data structure type - * and a separate function conatining the code. This function is passed a pointer to an instance of the data - * structure. This means that the code inside the functions must insert a pointer to the data structure whenever - * it wishes to access a Function Block variable. - * The variable_prefix_ variable will contain the correct string which needs to be prefixed to all variable accesses. - * This string is set with the set_variable_prefix() member function. - */ - const char *variable_prefix_; - - - - public: - generate_cc_base_c(stage4out_c *s4o_ptr): s4o(*s4o_ptr) {variable_prefix_ = NULL;} - ~generate_cc_base_c(void) {} - - void set_variable_prefix(const char *variable_prefix) {variable_prefix_ = variable_prefix;} - void print_variable_prefix(void) { - if (variable_prefix_ != NULL) - s4o.print(variable_prefix_); - } - - void *print_token(token_c *token, int offset = 0) { - return s4o.printupper((token->value)+offset); - } - - void *print_literal(symbol_c *type, symbol_c *value) { - s4o.print("__"); - type->accept(*this); - s4o.print("_LITERAL("); - value->accept(*this); - s4o.print(")"); - return NULL; - } - - void *print_striped_token(token_c *token, int offset = 0) { - std::string str = ""; - for (unsigned int i = offset; i < strlen(token->value); i++) - if (token->value[i] != '_') - str += token->value[i]; - return s4o.printupper(str); - } - - void *print_striped_binary_token(token_c *token, unsigned int offset = 0) { - /* convert the binary value to hexadecimal format... */ - unsigned char value, bit_mult; - unsigned int i; - int total_bits; - char str[2] = {'A', '\0'}; /* since the s4o object is not prepared to print out one character at a time... */ - - s4o.print("0x"); - - total_bits = 0; - for (i = offset; i < strlen(token->value); i++) - if (token->value[i] != '_') - total_bits++; - - value = 0; - bit_mult = (unsigned char)1 << (((total_bits+3)%4)+1); - for (i = offset; i < strlen(token->value); i++) { - if (token->value[i] != '_') { - bit_mult /= 2; - value += bit_mult * ((token->value[i] == '0')? 0:1); - if (bit_mult == 1) { - str[0] = (value <= 9)? (char)'0' + value : (char)'A' + value; - s4o.print(str); - bit_mult = 0x10; - value = 0; - } - } - } - - return NULL; - } - - void *print_list(list_c *list, - std::string pre_elem_str = "", - std::string inter_elem_str = "", - std::string post_elem_str = "", - visitor_c *visitor = NULL) { - if (visitor == NULL) visitor = this; - - if (list->n > 0) { -//std::cout << "generate_cc_base_c::print_list(n = " << list->n << ") 000\n"; - s4o.print(pre_elem_str); - list->elements[0]->accept(*visitor); - } - - for(int i = 1; i < list->n; i++) { -//std::cout << "generate_cc_base_c::print_list " << i << "\n"; - s4o.print(inter_elem_str); - list->elements[i]->accept(*visitor); - } - - if (list->n > 0) - s4o.print(post_elem_str); - - return NULL; - } - - - void *print_binary_expression(symbol_c *l_exp, - symbol_c *r_exp, - const char *operation) { - s4o.print("("); - l_exp->accept(*this); - s4o.print(operation); - r_exp->accept(*this); - s4o.print(")"); - return NULL; - } - - void *print_unary_expression(symbol_c *exp, - const char *operation) { - s4o.print(operation); - s4o.print("("); - exp->accept(*this); - s4o.print(")"); - return NULL; - } - - void *print_binary_function(const char *function, - symbol_c *l_exp, - symbol_c *r_exp) { - s4o.print(function); - s4o.print("("); - l_exp->accept(*this); - s4o.print(", "); - r_exp->accept(*this); - s4o.print(")"); - return NULL; - } - - void *print_compare_function(const char *function, - symbol_c *compare_type, - symbol_c *l_exp, - symbol_c *r_exp) { - s4o.print(function); - compare_type->accept(*this); - s4o.print("(2, "); - l_exp->accept(*this); - s4o.print(", "); - r_exp->accept(*this); - s4o.print(")"); - return NULL; - } - -/***************************/ -/* 2.1.6 - Pragmas */ -/***************************/ - /* Do not use print_token() as it will change everything into uppercase */ - void *visit(pragma_c *symbol) {return s4o.print(symbol->value);} - - -/***************************/ -/* B 0 - Programming Model */ -/***************************/ - /* leave for derived classes... */ - - - -/*************************/ -/* B.1 - Common elements */ -/*************************/ -/*******************************************/ -/* B 1.1 - Letters, digits and identifiers */ -/*******************************************/ - void *visit(identifier_c *symbol) {return print_token(symbol);} - -/*********************/ -/* B 1.2 - Constants */ -/*********************/ - /* originally empty... */ - -/******************************/ -/* B 1.2.1 - Numeric Literals */ -/******************************/ - void *visit(real_c *symbol) {return print_striped_token(symbol);} - void *visit(integer_c *symbol) {return print_striped_token(symbol);} - void *visit(binary_integer_c *symbol) {return print_striped_binary_token(symbol, 2);} - void *visit(octal_integer_c *symbol) {s4o.print("0"); return print_striped_token(symbol, 2);} - void *visit(hex_integer_c *symbol) {s4o.print("0x"); return print_striped_token(symbol, 3);} - - void *visit(numeric_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} - void *visit(integer_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} - void *visit(real_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} - void *visit(bit_string_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} - void *visit(boolean_literal_c *symbol) {return print_literal(symbol->type, symbol->value);} - - /* helper class for boolean_literal_c */ - void *visit(boolean_true_c *symbol) {s4o.print("TRUE"); return NULL;} - void *visit(boolean_false_c *symbol) {s4o.print("FALSE"); return NULL;} - -/*******************************/ -/* B.1.2.2 Character Strings */ -/*******************************/ - void *visit(double_byte_character_string_c *symbol) { - // TO DO ... - ERROR; - return print_token(symbol); - } - - void *visit(single_byte_character_string_c *symbol) { - std::string str = ""; - unsigned int count = 0; - str += '"'; - /* we ignore the first and last bytes, they will be the character ' */ - for (unsigned int i = 1; i < strlen(symbol->value) - 1; i++) { - char c = symbol->value[i]; - if ((c == '\\') || (c == '"')) - {str += '\\'; str += c; count ++; continue;} - if (c != '$') - {str += c; count++; continue;} - /* this should be safe, since the code has passed the syntax parser!! */ - c = symbol->value[++i]; - switch (c) { - case '$': - case '\'': - {str += c; count++; continue;} - case 'L': - case 'l': - {str += "\x0A"; /* LF */; count++; continue;} - case 'N': - case 'n': - {str += "\\x0A"; /* NL */; count++; continue;} - case 'P': - case 'p': - {str += "\\f"; /* FF */; count++; continue;} - case 'R': - case 'r': - {str += "\\r"; /* CR */; count++; continue;} - case 'T': - case 't': - {str += "\\t"; /* tab */; count++; continue;} - default: { - if (isxdigit(c)) { - /* this should be safe, since the code has passed the syntax parser!! */ - char c2 = symbol->value[++i]; - if (isxdigit(c2)) { - str += '\\'; str += 'x'; str += c; str += c2; - count++; continue; - } - } - } - /* otherwise we have an invalid string!! */ - /* This should not have got through the syntax parser! */ - ERROR; - } /* switch() */ - } /* for() */ - - str += '"'; - s4o.print("(STRING){"); - s4o.print_integer(count); - s4o.print(","); - s4o.print(str); - s4o.print("}"); - return NULL; - } - - -/***************************/ -/* B 1.2.3 - Time Literals */ -/***************************/ - -/************************/ -/* B 1.2.3.1 - Duration */ -/************************/ -/* The following output is actually the parameters to the constructor of the TIME class! */ - -/* SYM_REF0(neg_time_c) */ -void *visit(neg_time_c *symbol) {s4o.print("-1"); /* negative time value */; return NULL;} - - -/* SYM_REF2(duration_c, neg, interval) */ -void *visit(duration_c *symbol) { - TRACE("duration_c"); - s4o.print("__time_to_timespec("); - if (NULL == symbol->neg) - s4o.print("1"); /* positive time value */ - else - symbol->neg->accept(*this); /* this will print '-1' :-) */ - - s4o.print(", "); - - symbol->interval->accept(*this); - if (typeid(*symbol->interval) == typeid(hours_c)) {s4o.print(", 0");} - if (typeid(*symbol->interval) == typeid(minutes_c)) {s4o.print(", 0, 0");} - if (typeid(*symbol->interval) == typeid(seconds_c)) {s4o.print(", 0, 0, 0");} - if (typeid(*symbol->interval) == typeid(milliseconds_c)) {s4o.print(", 0, 0, 0, 0");} - s4o.print(")"); - return NULL; -} - - -/* SYM_TOKEN(fixed_point_c) */ -void *visit(fixed_point_c *symbol) {return print_token(symbol);} - - -/* SYM_REF2(days_c, days, hours) */ -void *visit(days_c *symbol) { - TRACE("days_c"); - if (NULL == symbol->hours) - s4o.print("0, 0, 0, 0"); /* milliseconds, seconds, minutes, hours */ - else - symbol->hours->accept(*this); - - s4o.print(", "); - - symbol->days->accept(*this); - return NULL; -} - - -/* SYM_REF2(hours_c, hours, minutes) */ -void *visit(hours_c *symbol) { - TRACE("hours_c"); - if (NULL == symbol->minutes) - s4o.print("0, 0, 0"); /* milliseconds, seconds, minutes */ - else - symbol->minutes->accept(*this); - - s4o.print(", "); - - symbol->hours->accept(*this); - return NULL; -} - - -/* SYM_REF2(minutes_c, minutes, seconds) */ -void *visit(minutes_c *symbol) { - TRACE("minutes_c"); - if (NULL == symbol->seconds) - s4o.print("0, 0"); /* milliseconds, seconds */ - else - symbol->seconds->accept(*this); - - s4o.print(", "); - - symbol->minutes->accept(*this); - return NULL; -} - - -/* SYM_REF2(seconds_c, seconds, milliseconds) */ -void *visit(seconds_c *symbol) { - TRACE("seconds_c"); - if (NULL == symbol->milliseconds) - s4o.print("0"); /* milliseconds */ - else - symbol->milliseconds->accept(*this); - - s4o.print(", "); - - symbol->seconds->accept(*this); - return NULL; -} - - -/* SYM_REF2(milliseconds_c, milliseconds, unused) */ -void *visit(milliseconds_c *symbol) { - TRACE("milliseconds_c"); - symbol->milliseconds->accept(*this); - return NULL; -} - -/************************************/ -/* B 1.2.3.2 - Time of day and Date */ -/************************************/ - -/* SYM_REF2(time_of_day_c, daytime, unused) */ -void *visit(time_of_day_c *symbol) { - TRACE("time_of_day_c"); - s4o.print("__tod_to_timespec("); - symbol->daytime->accept(*this); - s4o.print(")"); - return NULL; -} - - -/* SYM_REF4(daytime_c, day_hour, day_minute, day_second, unused) */ -void *visit(daytime_c *symbol) { - TRACE("daytime_c"); - symbol->day_second->accept(*this); - s4o.print(", "); - symbol->day_minute->accept(*this); - s4o.print(", "); - symbol->day_hour->accept(*this); - return NULL; -} - - -/* SYM_REF2(date_c, date_literal, unused) */ -void *visit(date_c *symbol) { - TRACE("date_c"); - s4o.print("__date_to_timespec("); - symbol->date_literal->accept(*this); - s4o.print(")"); - return NULL; -} - - -/* SYM_REF4(date_literal_c, year, month, day, unused) */ -void *visit(date_literal_c *symbol) { - TRACE("date_literal_c"); - symbol->day->accept(*this); - s4o.print(", "); - symbol->month->accept(*this); - s4o.print(", "); - symbol->year->accept(*this); - return NULL; -} - - -/* SYM_REF2(date_and_time_c, date_literal, daytime) */ -void *visit(date_and_time_c *symbol) { - TRACE("date_and_time_c"); - s4o.print("__dt_to_timespec("); - symbol->daytime->accept(*this); - s4o.print(", "); - symbol->date_literal->accept(*this); - s4o.print(")"); - return NULL; -} - - -/**********************/ -/* B.1.3 - Data types */ -/**********************/ -/***********************************/ -/* B 1.3.1 - Elementary Data Types */ -/***********************************/ - void *visit(time_type_name_c *symbol) {s4o.print("TIME"); return NULL;} - void *visit(bool_type_name_c *symbol) {s4o.print("BOOL"); return NULL;} - void *visit(sint_type_name_c *symbol) {s4o.print("SINT"); return NULL;} - void *visit(int_type_name_c *symbol) {s4o.print("INT"); return NULL;} - void *visit(dint_type_name_c *symbol) {s4o.print("DINT"); return NULL;} - void *visit(lint_type_name_c *symbol) {s4o.print("LINT"); return NULL;} - void *visit(usint_type_name_c *symbol) {s4o.print("USINT"); return NULL;} - void *visit(uint_type_name_c *symbol) {s4o.print("UINT"); return NULL;} - void *visit(udint_type_name_c *symbol) {s4o.print("UDINT"); return NULL;} - void *visit(ulint_type_name_c *symbol) {s4o.print("ULINT"); return NULL;} - void *visit(real_type_name_c *symbol) {s4o.print("REAL"); return NULL;} - void *visit(lreal_type_name_c *symbol) {s4o.print("LREAL"); return NULL;} - void *visit(date_type_name_c *symbol) {s4o.print("DATE"); return NULL;} - void *visit(tod_type_name_c *symbol) {s4o.print("TOD"); return NULL;} - void *visit(dt_type_name_c *symbol) {s4o.print("DT"); return NULL;} - void *visit(byte_type_name_c *symbol) {s4o.print("BYTE"); return NULL;} - void *visit(word_type_name_c *symbol) {s4o.print("WORD"); return NULL;} - void *visit(lword_type_name_c *symbol) {s4o.print("LWORD"); return NULL;} - void *visit(dword_type_name_c *symbol) {s4o.print("DWORD"); return NULL;} - void *visit(string_type_name_c *symbol) {s4o.print("STRING"); return NULL;} - void *visit(wstring_type_name_c *symbol) {s4o.print("WSTRING"); return NULL;} - -/********************************/ -/* B.1.3.2 - Generic data types */ -/********************************/ - /* originally empty... */ - -/********************************/ -/* B 1.3.3 - Derived data types */ -/********************************/ - /* leave for derived classes... */ - -/*********************/ -/* B 1.4 - Variables */ -/*********************/ -void *visit(symbolic_variable_c *symbol) { - TRACE("symbolic_variable_c"); - this->print_variable_prefix(); - symbol->var_name->accept(*this); - return NULL; -} - -/********************************************/ -/* B.1.4.1 Directly Represented Variables */ -/********************************************/ -void *visit(direct_variable_c *symbol) { - TRACE("direct_variable_c"); - /* Do not use print_token() as it will change everything into uppercase */ - return s4o.printlocation(symbol->value); -} - - - -/*************************************/ -/* B.1.4.2 Multi-element Variables */ -/*************************************/ -#if 0 -/* subscripted_variable '[' subscript_list ']' */ -SYM_REF2(array_variable_c, subscripted_variable, subscript_list) - -/* subscript_list ',' subscript */ -SYM_LIST(subscript_list_c) -#endif - -/* record_variable '.' field_selector */ -/* WARNING: input and/or output variables of function blocks - * may be accessed as fields of a structured variable! - * Code handling a structured_variable_c must take - * this into account! - */ -// SYM_REF2(structured_variable_c, record_variable, field_selector) -void *visit(structured_variable_c *symbol) { - TRACE("structured_variable_c"); - - symbol->record_variable->accept(*this); - s4o.print("."); - symbol->field_selector->accept(*this); - return NULL; -} - -/******************************************/ -/* B 1.4.3 - Declaration & Initialisation */ -/******************************************/ - /* leave for derived classes... */ - -/**************************************/ -/* B.1.5 - Program organization units */ -/**************************************/ -/***********************/ -/* B 1.5.1 - Functions */ -/***********************/ - /* leave for derived classes... */ - -/*****************************/ -/* B 1.5.2 - Function Blocks */ -/*****************************/ - /* leave for derived classes... */ - -/**********************/ -/* B 1.5.3 - Programs */ -/**********************/ - /* leave for derived classes... */ - -/*********************************************/ -/* B.1.6 Sequential function chart elements */ -/*********************************************/ - -/********************************/ -/* B 1.7 Configuration elements */ -/********************************/ - /* leave for derived classes... */ - -/****************************************/ -/* B.2 - Language IL (Instruction List) */ -/****************************************/ -/***********************************/ -/* B 2.1 Instructions and Operands */ -/***********************************/ - /* leave for derived classes... */ - -/*******************/ -/* B 2.2 Operators */ -/*******************/ - /* leave for derived classes... */ - - -/***************************************/ -/* B.3 - Language ST (Structured Text) */ -/***************************************/ -/***********************/ -/* B 3.1 - Expressions */ -/***********************/ - /* leave for derived classes... */ - -/********************/ -/* B 3.2 Statements */ -/********************/ - /* leave for derived classes... */ - -/*********************************/ -/* B 3.2.1 Assignment Statements */ -/*********************************/ - /* leave for derived classes... */ - -/*****************************************/ -/* B 3.2.2 Subprogram Control Statements */ -/*****************************************/ - /* leave for derived classes... */ - -/********************************/ -/* B 3.2.3 Selection Statements */ -/********************************/ - /* leave for derived classes... */ - -/********************************/ -/* B 3.2.4 Iteration Statements */ -/********************************/ - /* leave for derived classes... */ - -}; /* class generate_cc_basic_c */ - - - - - - - - - - - - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/generate_cc_configbody.cc --- a/stage4/generate_cc/generate_cc_configbody.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,211 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * Build the body of the main function (currently named run() ) - * of the class onto which is mapped a specific CONFIGURATION. - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the IL and ST - * code. - */ - - - - - - -// #include /* required for NULL */ -/* -#include -#include - -#include "../../util/symtable.hh" - -#include "../stage4.hh" -*/ - - - - - -class generate_cc_configbody_c: public generate_cc_base_c { - - public: - generate_cc_configbody_c(stage4out_c *s4o_ptr) - : generate_cc_base_c(s4o_ptr) { - current_resource_name = NULL; - } - - virtual ~generate_cc_configbody_c(void) {} - - - private: - /* The name of the resource curretnly being processed... */ - symbol_c *current_resource_name; - - -/********************************/ -/* B 1.7 Configuration elements */ -/********************************/ - - -public: -/* -CONFIGURATION configuration_name - optional_global_var_declarations - (resource_declaration_list | single_resource_declaration) - optional_access_declarations - optional_instance_specific_initializations -END_CONFIGURATION -*/ -/* -SYM_REF6(configuration_declaration_c, configuration_name, global_var_declarations, resource_declarations, access_declarations, instance_specific_initializations, unused) -*/ -void *visit(configuration_declaration_c *symbol) { - TRACE("configuration_declaration_c"); - - symbol->resource_declarations->accept(*this); - return NULL; -} - - - -/* helper symbol for configuration_declaration */ -// SYM_LIST(resource_declaration_list_c) -void *visit(resource_declaration_list_c *symbol) { - TRACE("resource_declaration_list_c"); - - return print_list(symbol); -} - -/* -RESOURCE resource_name ON resource_type_name - optional_global_var_declarations - single_resource_declaration -END_RESOURCE -*/ -// SYM_REF4(resource_declaration_c, resource_name, resource_type_name, global_var_declarations, resource_declaration) -void *visit(resource_declaration_c *symbol) { - TRACE("resource_declaration_c"); - - current_resource_name = symbol->resource_name; - symbol->resource_declaration->accept(*this); - current_resource_name = NULL; - return NULL; -} - - - -/* task_configuration_list program_configuration_list */ -// SYM_REF2(single_resource_declaration_c, task_configuration_list, program_configuration_list) -void *visit(single_resource_declaration_c *symbol) { - TRACE("single_resource_declaration_c"); - - symbol->program_configuration_list->accept(*this); - return NULL; -} - - - -/* helper symbol for single_resource_declaration */ -//SYM_LIST(task_configuration_list_c) - - -/* helper symbol for single_resource_declaration */ -//SYM_LIST(program_configuration_list_c) -void *visit(program_configuration_list_c *symbol) { - TRACE("program_configuration_list_c"); - - return print_list(symbol); -} - - -/* helper symbol for - * - access_path - * - instance_specific_init - */ -//SYM_LIST(any_fb_name_list_c) - -/* [resource_name '.'] global_var_name ['.' structure_element_name] */ -//SYM_REF4(global_var_reference_c, resource_name, global_var_name, structure_element_name, unused) - -/* prev_declared_program_name '.' symbolic_variable */ -//SYM_REF2(program_output_reference_c, program_name, symbolic_variable) - -/* TASK task_name task_initialization */ -//SYM_REF2(task_configuration_c, task_name, task_initialization) - -/* '(' [SINGLE ASSIGN data_source ','] [INTERVAL ASSIGN data_source ','] PRIORITY ASSIGN integer ')' */ -//SYM_REF4(task_initialization_c, single_data_source, interval_data_source, priority_data_source, unused) - -/* PROGRAM [RETAIN | NON_RETAIN] program_name [WITH task_name] ':' program_type_name ['(' prog_conf_elements ')'] */ -//SYM_REF6(program_configuration_c, retain_option, program_name, task_name, program_type_name, prog_conf_elements, unused) -void *visit(program_configuration_c *symbol) { - TRACE("program_configuration_c"); - - s4o.print(s4o.indent_spaces); - if (NULL != current_resource_name) { - current_resource_name->accept(*this); - s4o.print("."); - } - symbol->program_name->accept(*this); - s4o.print(".f();\n"); - return NULL; -} - -/* prog_conf_elements ',' prog_conf_element */ -//SYM_LIST(prog_conf_elements_c) - -/* fb_name WITH task_name */ -//SYM_REF2(fb_task_c, fb_name, task_name) -// TODO... - -/* any_symbolic_variable ASSIGN prog_data_source */ -//SYM_REF2(prog_cnxn_assign_c, symbolic_variable, prog_data_source) - -/* any_symbolic_variable SENDTO data_sink */ -//SYM_REF2(prog_cnxn_sendto_c, symbolic_variable, prog_data_source) - -/* VAR_CONFIG instance_specific_init_list END_VAR */ -//SYM_REF2(instance_specific_initializations_c, instance_specific_init_list, unused) - -/* helper symbol for instance_specific_initializations */ -//SYM_LIST(instance_specific_init_list_c) - -/* resource_name '.' program_name '.' {fb_name '.'} - ((variable_name [location] ':' located_var_spec_init) | (fb_name ':' fb_initialization)) -*/ -//SYM_REF6(instance_specific_init_c, resource_name, program_name, any_fb_name_list, variable_name, location, initialization) - -/* helper symbol for instance_specific_init */ -/* function_block_type_name ':=' structure_initialization */ -//SYM_REF2(fb_initialization_c, function_block_type_name, structure_initialization) - - - -}; /* generate_cc_configbody_c */ - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/generate_cc_il.cc --- a/stage4/generate_cc/generate_cc_il.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1465 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * Conversion of il statements (i.e. IL code). - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the IL and ST - * code. - */ - - - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - -/* Returns the data type of an il_operand. - * - * Note that the il_operand may be a variable, in which case - * we return the type of the variable instance. - * The il_operand may also be a constant, in which case - * we return the data type of that constant. - * - * The variable instance may be a member of a structured variable, - * or an element in an array, or any combination of the two. - * - * The class constructor must be given the search scope - * (function, function block or program within which - * the possible il_operand variable instance was declared). - */ - -class search_il_operand_type_c { - - private: - search_varfb_instance_type_c search_varfb_instance_type; - search_constant_type_c search_constant_type; - - public: - search_il_operand_type_c(symbol_c *search_scope): search_varfb_instance_type(search_scope) {} - - public: - symbol_c *get_type(symbol_c *il_operand) { - symbol_c *res; - - /* We first assume that it is a constant... */ - res = search_constant_type.get_type(il_operand); - if (res != NULL) return res; - - /* Nope, now we assume it is a variable, and determine its type... */ - res = search_varfb_instance_type.get_type(il_operand); - if (NULL != res) return res; - - /* not found */ - return NULL; - } -}; - - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - - -/* A new class to ouput the il default variable to c++ code - * We use this class, inheriting from symbol_c, so it may be used - * as any other symbol_c object in the intermediate parse tree, - * more specifically, so it can be used as any other il operand. - * This makes the rest of the code much easier... - * - * Nevertheless, the basic visitor class visitor_c does not know - * how to visit this new il_default_variable_c class, so we have - * to extend that too. - * In reality extending the basic symbols doesn't quite work out - * as cleanly as desired (we need to use dynamic_cast in the - * accept method of the il_default_variable_c), but it is cleaner - * than the alternative... - */ -class il_default_variable_c; - -/* This visitor class is not really required, we could place the - * visit() method directly in genertae_cc_il_c, but doing it in - * a seperate class makes the architecture more evident... - */ -class il_default_variable_visitor_c { - public: - virtual void *visit(il_default_variable_c *symbol) = 0; - - virtual ~il_default_variable_visitor_c(void) {return;} -}; - - -/* A class to print out to the resulting C++ code - * the IL default variable name. - * - * It includes a reference to its name, - * and the data type of the data currently stored - * in this C++ variable... This is required because the - * C++ variable is a union, and we must know which member - * of the union top reference!! - * - * Note that we also need to keep track of the data type of - * the value currently being stored in the default variable. - * This is required so we can process parenthesis, - * - * e.g. : - * LD var1 - * AND ( - * LD var2 - * OR var3 - * ) - * - * Note that we only execute the 'AND (' operation when we come across - * the ')', i.e. once we have evaluated the result of the - * instructions inside the parenthesis. - * When we do execute the 'AND (' operation, we need to know the data type - * of the operand, which in this case is the result of the evaluation of the - * instruction list inside the parenthesis. We can only know this if we - * keep track of the data type currently stored in the default variable! - * - * We use the current_type inside the generate_cc_il::default_variable_name variable - * to track this! - */ -class il_default_variable_c: public symbol_c { - public: - symbol_c *var_name; /* in principle, this should point to an indentifier_c */ - symbol_c *current_type; - - public: - il_default_variable_c(const char *var_name_str, symbol_c *current_type); - virtual void *accept(visitor_c &visitor); -}; - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - - - -class generate_cc_il_c: public generate_cc_typedecl_c, il_default_variable_visitor_c { - - private: - /* When compiling il code, it becomes necessary to determine the - * data type of il operands. To do this, we must first find the - * il operand's declaration, within the scope of the function block - * or function currently being processed. - * The following object does just that... - * This object instance will then later be called while the - * remaining il code is being handled. - */ - //search_il_operand_type_c *search_il_operand_type; - search_expression_type_c *search_expression_type; - - /* The initial value that should be given to the IL default variable - * imediately after a parenthesis is opened. - * This variable is only used to pass data from the - * il_expression_c visitor to the simple_instr_list_c visitor. - * - * e.g.: - * LD var1 - * AND ( var2 - * OR var3 - * ) - * - * In the above code sample, the line 'AND ( var2' constitutes - * an il_expression_c, where var2 should be loaded into the - * il default variable before continuing with the expression - * inside the parenthesis. - * Unfortunately, only the simple_instr_list_c may do the - * initial laoding of the var2 bariable following the parenthesis, - * so the il_expression_c visitor will have to pass 'var2' as a - * parameter to the simple_instr_list_c visitor. - * Ergo, the existance of the following parameter...! - */ - symbol_c *il_default_variable_init_value; - - /* Operand to the IL operation currently being processed... */ - /* These variables are used to pass data from the - * il_simple_operation_c and il_expression_c visitors - * to the il operator visitors (i.e. LD_operator_c, - * LDN_operator_c, ST_operator_c, STN_operator_c, ...) - */ - symbol_c *current_operand; - symbol_c *current_operand_type; - - /* Label to which the current IL jump operation should jump to... */ - /* This variable is used to pass data from the - * il_jump_operation_c visitor - * to the il jump operator visitors (i.e. JMP_operator_c, - * JMPC_operator_c, JMPCN_operator_c, ...) - */ - symbol_c *jump_label; - - /* The result of the comparison IL operations (GT, EQ, LT, ...) - * is a boolean variable. - * This class keeps track of the current data type stored in the - * il default variable. This is usually done by keeping a reference - * to the data type of the last operand. Nevertheless, in the case of - * the comparison IL operators, the data type of the result (a boolean) - * is not the data type of the operand. We therefore need an object - * of the boolean data type to keep as a reference of the current - * data type. - * The following object is it... - */ - bool_type_name_c bool_type; - - /* the data type of the IL default variable... */ - #define IL_DEFVAR_T VAR_LEADER "IL_DEFVAR_T" - /* The name of the IL default variable... */ - #define IL_DEFVAR VAR_LEADER "IL_DEFVAR" - /* The name of the variable used to pass the result of a - * parenthesised instruction list to the immediately preceding - * scope ... - */ - #define IL_DEFVAR_BACK VAR_LEADER "IL_DEFVAR_BACK" - il_default_variable_c default_variable_name; - il_default_variable_c default_variable_back_name; - - /* Some function calls in the body of functions or function blocks - * may leave some parameters to their default values, and - * ignore some output parameters of the function being called. - * Our conversion of ST functions to C++ does not contemplate that, - * i.e. each called function must get all it's input and output - * parameters set correctly. - * For input parameters we merely need to call the function with - * the apropriate default value, but for output parameters - * we must create temporary variables to hold the output value. - * - * We declare all the temporary output variables at the begining of - * the body of each function or function block, and use them as - * in function calls later on as they become necessary... - * Note that we cannot create these variables just before a function - * call, as the function call itself may be integrated within an - * expression, or another function call! - * - * The variables are declared in the exact same order in which they - * will be used later on during the function calls, which allows us - * to simply re-create the name that was used for the temporary variable - * instead of keeping it in some list. - * The names are recreated by the temp_var_name_factory, after reset() - * has been called! - * - * This function will genertae code similar to... - * - * INT __TMP_0 = 23; - * REAL __TMP_1 = 45.5; - * ... - */ - temp_var_name_c temp_var_name_factory; - - /* When calling a function block, we must first find it's type, - * by searching through the declarations of the variables currently - * in scope. - * This class does just that... - * A new class is instantiated whenever we begin generating the code - * for a function block type declaration, or a program declaration. - * This object instance will then later be called while the - * function block's or the program's body is being handled. - * - * Note that functions cannot contain calls to function blocks, - * so we do not create an object instance when handling - * a function declaration. - */ - search_fb_instance_decl_c *search_fb_instance_decl; - - - public: - generate_cc_il_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) - : generate_cc_typedecl_c(s4o_ptr), - default_variable_name(IL_DEFVAR, NULL), - default_variable_back_name(IL_DEFVAR_BACK, NULL) - { - //search_il_operand_type = new search_il_operand_type_c(scope); - search_expression_type = new search_expression_type_c(scope); - search_fb_instance_decl = new search_fb_instance_decl_c(scope); - current_operand = NULL; - current_operand_type = NULL; - il_default_variable_init_value = NULL; - this->set_variable_prefix(variable_prefix); - } - - virtual ~generate_cc_il_c(void) { - delete search_fb_instance_decl; - //delete search_il_operand_type; - delete search_expression_type; - } - - void generate(instruction_list_c *il) { - generate_cc_tempvardecl_c generate_cc_tempvardecl(&s4o); - generate_cc_tempvardecl.generate(il, &temp_var_name_factory); - il->accept(*this); - } - - /* Declare the backup to the default variable, that will store the result - * of the IL operations executed inside a parenthesis... - */ - void declare_backup_variable(void) { - s4o.print(s4o.indent_spaces); - s4o.print(IL_DEFVAR_T); - s4o.print(" "); - print_backup_variable(); - s4o.print(";\n"); - } - - void print_backup_variable(void) { - this->default_variable_back_name.accept(*this); - } - - private: - /* A helper function... */ - /* - bool is_bool_type(symbol_c *type_symbol) { - return (NULL != dynamic_cast(type_symbol)); - } - */ - - /* A helper function... */ - void *XXX_operator(symbol_c *lo, const char *op, symbol_c *ro) { - if ((NULL == lo) || (NULL == ro)) ERROR; - if (NULL == op) ERROR; - - lo->accept(*this); - s4o.print(op); - ro->accept(*this); - return NULL; - } - - /* A helper function... */ - void *XXX_function(const char *func, symbol_c *lo, symbol_c *ro) { - if ((NULL == lo) || (NULL == ro)) ERROR; - if (NULL == func) ERROR; - - lo->accept(*this); - s4o.print(" = "); - s4o.print(func); - s4o.print("("); - lo->accept(*this); - s4o.print(", "); - ro->accept(*this); - s4o.print(")"); - return NULL; - } - - /* A helper function... */ - void *XXX_CAL_operator(const char *param_name, symbol_c *fb_name) { - if (NULL == fb_name) ERROR; - symbolic_variable_c *sv = dynamic_cast(fb_name); - if (NULL == sv) ERROR; - identifier_c *id = dynamic_cast(sv->var_name); - if (NULL == id) ERROR; - - identifier_c param(param_name); - - //SYM_REF3(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list) - il_param_assignment_c il_param_assignment(¶m, &this->default_variable_name, NULL); - // SYM_LIST(il_param_list_c) - il_param_list_c il_param_list; - il_param_list.add_element(&il_param_assignment); - CAL_operator_c CAL_operator; - // SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list) - il_fb_call_c il_fb_call(&CAL_operator, id, NULL, &il_param_list); - - il_fb_call.accept(*this); - return NULL; - } - - /* A helper function... */ - void *CMP_operator(symbol_c *o, const char *operation) { - if (NULL == o) ERROR; - if (NULL == this->default_variable_name.current_type) ERROR; - - symbol_c *backup = this->default_variable_name.current_type; - this->default_variable_name.current_type = &(this->bool_type); - this->default_variable_name.accept(*this); - this->default_variable_name.current_type = backup; - - s4o.print(" = "); - s4o.print(operation); - this->default_variable_name.current_type->accept(*this); - s4o.print("(2, "); - this->default_variable_name.accept(*this); - s4o.print(", "); - o->accept(*this); - s4o.print(")"); - - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = &(this->bool_type); - return NULL; - } - - - /* A helper function... */ - void C_modifier(void) { - if (search_expression_type->is_bool_type(default_variable_name.current_type)) { - s4o.print("if ("); - this->default_variable_name.accept(*this); - s4o.print(") "); - } - else {ERROR;} - } - - /* A helper function... */ - void CN_modifier(void) { - if (search_expression_type->is_bool_type(default_variable_name.current_type)) { - s4o.print("if (!"); - this->default_variable_name.accept(*this); - s4o.print(") "); - } - else {ERROR;} - } - - -public: -void *visit(il_default_variable_c *symbol) { - //s4o.print("il_default_variable_c VISITOR!!\n"); - symbol->var_name->accept(*this); - if (NULL != symbol->current_type) { - s4o.print("."); - symbol->current_type->accept(*this); - s4o.print("var"); - } - return NULL; -} - - -private: - -/********************************************/ -/* B.1.4.1 Directly Represented Variables */ -/********************************************/ -// direct_variable: direct_variable_token {$$ = new direct_variable_c($1);}; -void *visit(direct_variable_c *symbol) { - TRACE("direct_variable_c"); - /* Do not use print_token() as it will change everything into uppercase */ - if (strlen(symbol->value) == 0) ERROR; - s4o.print("*("); - this->print_variable_prefix(); - s4o.printlocation(symbol->value + 1); - s4o.print(")"); - return NULL; -} - -/****************************************/ -/* B.2 - Language IL (Instruction List) */ -/****************************************/ - -/***********************************/ -/* B 2.1 Instructions and Operands */ -/***********************************/ - -/* please see the comment before the RET_operator_c visitor for details... */ -#define END_LABEL VAR_LEADER "end" - -/*| instruction_list il_instruction */ -void *visit(instruction_list_c *symbol) { - - /* Declare the backup to the default variable, that will store the result - * of the IL operations executed inside a parenthesis... - */ - declare_backup_variable(); - - /* Declare the default variable, that will store the result of the IL operations... */ - s4o.print(s4o.indent_spaces); - s4o.print(IL_DEFVAR_T); - s4o.print(" "); - this->default_variable_name.accept(*this); - s4o.print(";\n\n"); - - print_list(symbol, s4o.indent_spaces, ";\n" + s4o.indent_spaces, ";\n"); - - /* write the label marking the end of the code block */ - /* please see the comment before the RET_operator_c visitor for details... */ - s4o.print("\n"); - s4o.print(s4o.indent_spaces); - s4o.print(END_LABEL); - s4o.print(":\n"); - s4o.indent_right(); - /* since every label must be followed by at least one statement, and - * only the functions will introduce the return statement after this label, - * function blocks written in IL would result in invalid C++ code. - * To work around this we introduce the equivalent of a 'nop' operation - * to humour the compiler... - */ - s4o.print(s4o.indent_spaces); - s4o.print("/* to humour the compiler, we insert a nop */\n"); - s4o.print(s4o.indent_spaces); - this->default_variable_name.accept(*this); - s4o.print(" = "); - this->default_variable_name.accept(*this); - s4o.print(";\n"); - s4o.indent_left(); - - return NULL; -} - - -/* | label ':' [il_incomplete_instruction] eol_list */ -// SYM_REF2(il_instruction_c, label, il_instruction) -void *visit(il_instruction_c *symbol) { - if (NULL != symbol->label) { - symbol->label->accept(*this); - s4o.print(":\n"); - s4o.print(s4o.indent_spaces); - } - symbol->il_instruction->accept(*this); - return NULL; -} - -/* | il_simple_operator [il_operand] */ -//SYM_REF2(il_simple_operation_c, il_simple_operator, il_operand) -void *visit(il_simple_operation_c *symbol) { - this->current_operand = symbol->il_operand; - if (NULL == this->current_operand) { - this->current_operand_type = NULL; - } else { - this->current_operand_type = search_expression_type->get_type(this->current_operand); - if (NULL == this->current_operand_type) ERROR; - } - - symbol->il_simple_operator->accept(*this); - - this->current_operand = NULL; - this->current_operand_type = NULL; - return NULL; -} - - -/* | function_name [il_operand_list] */ -// SYM_REF2(il_function_call_c, function_name, il_operand_list) -void *visit(il_function_call_c *symbol) { - function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name); - - if (f_decl == function_symtable.end_value()) { - /* should never occur. The function being called MUST be in the symtable... */ - function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name); - if (current_function_type == function_none) ERROR; - - symbol_c *param_data_type = default_variable_name.current_type; - symbol_c *return_data_type = (symbol_c *)search_expression_type->compute_standard_function_il(symbol, param_data_type); - if (NULL == return_data_type) ERROR; - - default_variable_name.current_type = return_data_type; - this->default_variable_name.accept(*this); - default_variable_name.current_type = param_data_type; - s4o.print(" = "); - - function_call_param_iterator_c function_call_param_iterator(symbol); - - int nb_param = 1; - if (symbol->il_operand_list != NULL) - nb_param += ((list_c *)symbol->il_operand_list)->n; - -#include "il_code_gen.c" - -#if 0 - for(int current_param = 0; current_param < nb_param; current_param++) { - symbol_c *param_value; - if (current_param == 0) - param_value = &this->default_variable_name; - else { - symbol_c *param_name = NULL; - switch (current_function_type) { - default: ERROR; - } - - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(param_name); - delete param_name; - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - - if (param_value == NULL) ERROR; - } - - switch (current_function_type) { - case (function_sqrt): - if (current_param == 0) { - s4o.print("sqrt("); - param_value->accept(*this); - s4o.print(")"); - } - else ERROR; - break; - default: ERROR; - } - } /* for(...) */ -#endif - - /* the data type returned by the function, and stored in the il default variable... */ - default_variable_name.current_type = return_data_type; - } - else { - /* determine the base data type returned by the function being called... */ - search_base_type_c search_base_type; - symbol_c *return_data_type = (symbol_c *)f_decl->type_name->accept(search_base_type); - symbol_c *param_data_type = default_variable_name.current_type; - if (NULL == return_data_type) ERROR; - - default_variable_name.current_type = return_data_type; - this->default_variable_name.accept(*this); - default_variable_name.current_type = param_data_type; - s4o.print(" = "); - - symbol->function_name->accept(*this); - s4o.print("("); - - /* loop through each function parameter, find the value we should pass - * to it, and then output the c equivalent... - */ - - function_param_iterator_c fp_iterator(f_decl); - identifier_c *param_name; - function_call_param_iterator_c function_call_param_iterator(symbol); - for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { - if (i != 1) - s4o.print(", "); - - symbol_c *param_type = fp_iterator.param_type(); - if (param_type == NULL) ERROR; - - function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); - - - symbol_c *param_value = NULL; - - /* if it is the first parameter, semantics specifies that we should - * get the value off the IL default variable! - */ - if (1 == i) - param_value = &this->default_variable_name; - - /* Get the value from a foo( = ) style call */ - /* NOTE: the following line of code is not required in this case, but it doesn't - * harm to leave it in, as in the case of a non-formal syntax function call, - * it will always return NULL. - * We leave it in in case we later decide to merge this part of the code together - * with the function calling code in generate_cc_st_c, which does require - * the following line... - */ - if (param_value == NULL) - param_value = function_call_param_iterator.search(param_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - - switch (param_direction) { - case function_param_iterator_c::direction_in: - if (param_value == NULL) { - /* No value given for parameter, so we must use the default... */ - /* First check whether default value specified in function declaration...*/ - param_value = fp_iterator.default_value(); - } - if (param_value == NULL) { - /* If not, get the default value of this variable's type */ - param_value = (symbol_c *)param_type->accept(*type_initial_value_c::instance()); - } - if (param_value == NULL) ERROR; - param_value->accept(*this); - break; - case function_param_iterator_c::direction_out: - case function_param_iterator_c::direction_inout: - if (param_value == NULL) { - /* no parameter value given, so we pass a previously declared temporary variable. */ - std::string *temp_var_name = temp_var_name_factory.new_name(); - s4o.print(*temp_var_name); - delete temp_var_name; - } else { - param_value->accept(*this); - } - break; - case function_param_iterator_c::direction_extref: - /* TODO! */ - ERROR; - break; - } /* switch */ - } /* for(...) */ - - s4o.print(")"); - /* the data type returned by the function, and stored in the il default variable... */ - default_variable_name.current_type = return_data_type; - } - - return NULL; -} - - -/* | il_expr_operator '(' [il_operand] eol_list [simple_instr_list] ')' */ -//SYM_REF4(il_expression_c, il_expr_operator, il_operand, simple_instr_list, unused) -void *visit(il_expression_c *symbol) { - /* We will be recursevely interpreting an instruction list, - * so we store a backup of the data type of the value currently stored - * in the default variable, and set the current data type to NULL - */ - symbol_c *old_current_default_variable_data_type = this->default_variable_name.current_type; - this->default_variable_name.current_type = NULL; - - /* Pass the symbol->il_operand to the simple_instr_list visitor - * using the il_default_variable_init_value parameter... - * Note that the simple_instr_list_c visitor will set this parameter - * to NULL as soon as it does not require it any longer, - * so we don't do it here again after the - * symbol->simple_instr_list->accept(*this); - * returns... - */ - this->il_default_variable_init_value = symbol->il_operand; - - /* Now do the parenthesised instructions... */ - /* NOTE: the following code line will get the variable - * this->default_variable_name.current_type updated! - */ - symbol->simple_instr_list->accept(*this); - - /* Now do the operation, using the previous result! */ - /* NOTE: The result of the previous instruction list will be stored - * in a variable named IL_DEFVAR_BACK. This is done in the visitor - * to instruction_list_c objects... - */ - this->current_operand = &(this->default_variable_back_name); - this->current_operand_type = this->default_variable_back_name.current_type; - - this->default_variable_name.current_type = old_current_default_variable_data_type; - if (NULL == this->current_operand_type) ERROR; - - symbol->il_expr_operator->accept(*this); - - this->current_operand = NULL; - this->current_operand_type = NULL; - this->default_variable_back_name.current_type = NULL; - return NULL; -} - -/* il_jump_operator label */ -// SYM_REF2(il_jump_operation_c, il_jump_operator, label) -void *visit(il_jump_operation_c *symbol) { - /* Pass the symbol->label to the il_jump_operation visitor - * using the jump_label parameter... - */ - this->jump_label = symbol->label; - symbol->il_jump_operator->accept(*this); - this->jump_label = NULL; - - return NULL; -} - -/* il_call_operator prev_declared_fb_name - * | il_call_operator prev_declared_fb_name '(' ')' - * | il_call_operator prev_declared_fb_name '(' eol_list ')' - * | il_call_operator prev_declared_fb_name '(' il_operand_list ')' - * | il_call_operator prev_declared_fb_name '(' eol_list il_param_list ')' - */ -// SYM_REF4(il_fb_call_c, il_call_operator, fb_name, il_operand_list, il_param_list) -void *visit(il_fb_call_c *symbol) { - symbol->il_call_operator->accept(*this); - s4o.print("{\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - - /* first figure out what is the name of the function block type of the function block being called... */ - symbol_c *function_block_type_name = this->search_fb_instance_decl->get_type_name(symbol->fb_name); - /* should never occur. The function block instance MUST have been declared... */ - if (function_block_type_name == NULL) ERROR; - - /* Now find the declaration of the function block type being called... */ - function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(function_block_type_name); - /* should never occur. The function block type being called MUST be in the symtable... */ - if (fb_decl == function_block_type_symtable.end_value()) ERROR; - - /* loop through each function block parameter, find the value we should pass - * to it, and then output the c equivalent... - */ - function_param_iterator_c fp_iterator(fb_decl); - identifier_c *param_name; - function_call_param_iterator_c function_call_param_iterator(symbol); - for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { - function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); - - /* Get the value from a foo( = ) style call */ - symbol_c *param_value = function_call_param_iterator.search(param_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - - /* now output the value assignment */ - if (param_value != NULL) - if ((param_direction == function_param_iterator_c::direction_in) || - (param_direction == function_param_iterator_c::direction_inout)) { - symbol->fb_name->accept(*this); - s4o.print("."); - param_name->accept(*this); - s4o.print(" = "); - param_value->accept(*this); - s4o.print(";\n" + s4o.indent_spaces); - } - } /* for(...) */ - - /* now call the function... */ - function_block_type_name->accept(*this); - s4o.print(FB_FUNCTION_SUFFIX); - s4o.print("(&"); - symbol->fb_name->accept(*this); - s4o.print(")"); - - /* loop through each function parameter, find the variable to which - * we should atribute the value of all output or inoutput parameters. - */ - fp_iterator.reset(); - function_call_param_iterator.reset(); - for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { - function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); - - /* Get the value from a foo( = ) style call */ - symbol_c *param_value = function_call_param_iterator.search(param_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - - /* now output the value assignment */ - if (param_value != NULL) - if ((param_direction == function_param_iterator_c::direction_out) || - (param_direction == function_param_iterator_c::direction_inout)) { - s4o.print(";\n"+ s4o.indent_spaces); - param_value->accept(*this); - s4o.print(" = "); - symbol->fb_name->accept(*this); - s4o.print("."); - param_name->accept(*this); - } - } /* for(...) */ - - s4o.print(";\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces); - s4o.print("}"); - - return NULL; -} - - - -/* | function_name '(' eol_list [il_param_list] ')' */ -// SYM_REF2(il_formal_funct_call_c, function_name, il_param_list) -void *visit(il_formal_funct_call_c *symbol) { - function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name); - - if (f_decl == function_symtable.end_value()) - /* should never occur. The function being called MUST be in the symtable... */ - ERROR; - - symbol->function_name->accept(*this); - s4o.print("("); - - /* loop through each function parameter, find the value we should pass - * to it, and then output the c equivalent... - */ - - function_param_iterator_c fp_iterator(f_decl); - identifier_c *param_name; - function_call_param_iterator_c function_call_param_iterator(symbol); - for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { - if (i != 1) - s4o.print(", "); - - symbol_c *param_type = fp_iterator.param_type(); - if (param_type == NULL) ERROR; - - function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); - - - symbol_c *param_value = NULL; - - /* Get the value from a foo( = ) style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.search(param_name); - - /* Get the value from a foo() style call */ - /* NOTE: the following line of code is not required in this case, but it doesn't - * harm to leave it in, as in the case of a formal syntax function call, - * it will always return NULL. - * We leave it in in case we later decide to merge this part of the code together - * with the function calling code in generate_cc_st_c, which does require - * the following line... - */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - - switch (param_direction) { - case function_param_iterator_c::direction_in: - if (param_value == NULL) { - /* No value given for parameter, so we must use the default... */ - /* First check whether default value specified in function declaration...*/ - param_value = fp_iterator.default_value(); - } - if (param_value == NULL) { - /* If not, get the default value of this variable's type */ - param_value = (symbol_c *)param_type->accept(*type_initial_value_c::instance()); - } - if (param_value == NULL) ERROR; - param_value->accept(*this); - break; - case function_param_iterator_c::direction_out: - case function_param_iterator_c::direction_inout: - if (param_value == NULL) { - /* no parameter value given, so we pass a previously declared temporary variable. */ - std::string *temp_var_name = temp_var_name_factory.new_name(); - s4o.print(*temp_var_name); - delete temp_var_name; - } else { - param_value->accept(*this); - } - break; - case function_param_iterator_c::direction_extref: - /* TODO! */ - ERROR; - break; - } /* switch */ - } /* for(...) */ - - // symbol->parameter_assignment->accept(*this); - s4o.print(")"); - return NULL; -} - - -/* | il_operand_list ',' il_operand */ -// SYM_LIST(il_operand_list_c) -void *visit(il_operand_list_c *symbol) {ERROR; return NULL;} // should never get called! - - -/* | simple_instr_list il_simple_instruction */ -// SYM_LIST(simple_instr_list_c) -void *visit(simple_instr_list_c *symbol) { - /* A simple_instr_list_c is used to store a list of il operations - * being done within parenthesis... - * - * e.g.: - * LD var1 - * AND ( var2 - * OR var3 - * OR var4 - * ) - * - * This will be converted to C++ by defining a new scope - * with a new il default variable, and executing the il operands - * within this new scope. - * At the end of the scope the result, i.e. the value currently stored - * in the il default variable is copied to the variable used to take this - * value to the outside scope... - * - * The above example will result in the following C++ code: - * {__IL_DEFVAR_T __IL_DEFVAR_BACK; - * __IL_DEFVAR_T __IL_DEFVAR; - * - * __IL_DEFVAR.INTvar = var1; - * { - * __IL_DEFVAR_T __IL_DEFVAR; - * - * __IL_DEFVAR.INTvar = var2; - * __IL_DEFVAR.INTvar |= var3; - * __IL_DEFVAR.INTvar |= var4; - * - * __IL_DEFVAR_BACK = __IL_DEFVAR; - * } - * __IL_DEFVAR.INTvar &= __IL_DEFVAR_BACK.INTvar; - * - * } - * - * The intial value of the il default variable (in the above - * example 'var2') is passed to this simple_instr_list_c visitor - * using the il_default_variable_init_value parameter. - * Since it is possible to have parenthesis inside other parenthesis - * recursively, we reset the il_default_variable_init_value to NULL - * as soon as we no longer require it, as it may be used once again - * in the line - * print_list(symbol, s4o.indent_spaces, ";\n" + s4o.indent_spaces, ";\n"); - * - */ - - /* Declare the default variable, that will store the result of the IL operations... */ - s4o.print("{\n"); - s4o.indent_right(); - - s4o.print(s4o.indent_spaces); - s4o.print(IL_DEFVAR_T); - s4o.print(" "); - this->default_variable_name.accept(*this); - s4o.print(";\n\n"); - - /* Check whether we should initiliase the il default variable... */ - if (NULL != this->il_default_variable_init_value) { - /* Yes, we must... */ - /* We will do it by instatiating a LD operator, and having this - * same generate_cc_il_c class visiting it! - */ - LD_operator_c ld_oper; - il_simple_operation_c il_simple_oper(&ld_oper, this->il_default_variable_init_value); - - s4o.print(s4o.indent_spaces); - il_simple_oper.accept(*this); - s4o.print(";\n"); - } - - /* this parameter no longer required... */ - this->il_default_variable_init_value = NULL; - - print_list(symbol, s4o.indent_spaces, ";\n" + s4o.indent_spaces, ";\n"); - - /* copy the result in the default variable to the variable - * used to pass the data out to the scope enclosing - * the current scope! - * - * We also need to update the data type currently stored within - * the variable used to pass the data to the outside scope... - */ - this->default_variable_back_name.current_type = this->default_variable_name.current_type; - s4o.print("\n"); - s4o.print(s4o.indent_spaces); - this->default_variable_back_name.accept(*this); - s4o.print(" = "); - this->default_variable_name.accept(*this); - s4o.print(";\n"); - - s4o.indent_left(); - s4o.print(s4o.indent_spaces); - s4o.print("}\n"); - s4o.print(s4o.indent_spaces); - return NULL; -} - -/* | il_initial_param_list il_param_instruction */ -// SYM_LIST(il_param_list_c) -void *visit(il_param_list_c *symbol) {ERROR; return NULL;} // should never get called! - -/* il_assign_operator il_operand - * | il_assign_operator '(' eol_list simple_instr_list ')' - */ -// SYM_REF4(il_param_assignment_c, il_assign_operator, il_operand, simple_instr_list, unused) -void *visit(il_param_assignment_c *symbol) {ERROR; return NULL;} // should never get called! - -/* il_assign_out_operator variable */ -// SYM_REF2(il_param_out_assignment_c, il_assign_out_operator, variable); -void *visit(il_param_out_assignment_c *symbol) {ERROR; return NULL;} // should never get called! - -/*******************/ -/* B 2.2 Operators */ -/*******************/ - -void *visit(LD_operator_c *symbol) { - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - XXX_operator(&(this->default_variable_name), " = ", this->current_operand); - return NULL; -} - -void *visit(LDN_operator_c *symbol) { - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - XXX_operator(&(this->default_variable_name), - search_expression_type->is_bool_type(this->current_operand_type)?" = !":" = ~", - this->current_operand); - return NULL; -} - -void *visit(ST_operator_c *symbol) { - XXX_operator(this->current_operand, " = ",&(this->default_variable_name)); - /* the data type resulting from this operation is unchamged. */ - return NULL; -} - -void *visit(STN_operator_c *symbol) { - XXX_operator(this->current_operand, - search_expression_type->is_bool_type(this->current_operand_type)?" = !":" = ~", - &(this->default_variable_name)); - /* the data type resulting from this operation is unchamged. */ - return NULL; -} - -void *visit(NOT_operator_c *symbol) { - if ((NULL != this->current_operand) || (NULL != this->current_operand_type)) ERROR; - XXX_operator(&(this->default_variable_name), - search_expression_type->is_bool_type(this->default_variable_name.current_type)?" = !":" = ~", - &(this->default_variable_name)); - /* the data type resulting from this operation is unchanged. */ - return NULL; -} - -void *visit(S_operator_c *symbol) { - if ((NULL == this->current_operand) || (NULL == this->current_operand_type)) ERROR; - - C_modifier(); - this->current_operand->accept(*this); - s4o.print(search_expression_type->is_bool_type(this->current_operand_type)?" = true":" = 1"); - /* the data type resulting from this operation is unchanged! */ - return NULL; -} - -void *visit(R_operator_c *symbol) { - if ((NULL == this->current_operand) || (NULL == this->current_operand_type)) ERROR; - - C_modifier(); - this->current_operand->accept(*this); - s4o.print(search_expression_type->is_bool_type(this->current_operand_type)?" = false":" = 0"); - /* the data type resulting from this operation is unchanged! */ - return NULL; -} - -void *visit(S1_operator_c *symbol) {return XXX_CAL_operator("S1", this->current_operand);} -void *visit(R1_operator_c *symbol) {return XXX_CAL_operator("R1", this->current_operand);} -void *visit(CLK_operator_c *symbol) {return XXX_CAL_operator("CLK", this->current_operand);} -void *visit(CU_operator_c *symbol) {return XXX_CAL_operator("CU", this->current_operand);} -void *visit(CD_operator_c *symbol) {return XXX_CAL_operator("CD", this->current_operand);} -void *visit(PV_operator_c *symbol) {return XXX_CAL_operator("PV", this->current_operand);} -void *visit(IN_operator_c *symbol) {return XXX_CAL_operator("IN", this->current_operand);} -void *visit(PT_operator_c *symbol) {return XXX_CAL_operator("PT", this->current_operand);} - -void *visit(AND_operator_c *symbol) { - if (search_expression_type->is_binary_type(this->default_variable_name.current_type) && - search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { - XXX_operator(&(this->default_variable_name), " &= ", this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - } - else {ERROR;} - return NULL; -} - -void *visit(OR_operator_c *symbol) { - if (search_expression_type->is_binary_type(this->default_variable_name.current_type) && - search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { - XXX_operator(&(this->default_variable_name), " |= ", this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - } - else {ERROR;} - return NULL; -} - -void *visit(XOR_operator_c *symbol) { - if (search_expression_type->is_binary_type(this->default_variable_name.current_type) && - search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { - // '^' is a bit by bit exclusive OR !! Also seems to work with boolean types! - XXX_operator(&(this->default_variable_name), " ^= ", this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - } - else {ERROR;} - return NULL; -} - -void *visit(ANDN_operator_c *symbol) { - if (search_expression_type->is_binary_type(this->default_variable_name.current_type) && - search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { - XXX_operator(&(this->default_variable_name), - search_expression_type->is_bool_type(this->current_operand_type)?" &= !":" &= ~", - this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - } - else {ERROR;} - return NULL; -} - -void *visit(ORN_operator_c *symbol) { - if (search_expression_type->is_binary_type(this->default_variable_name.current_type) && - search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { - XXX_operator(&(this->default_variable_name), - search_expression_type->is_bool_type(this->current_operand_type)?" |= !":" |= ~", - this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - } - else {ERROR;} - return NULL; -} - -void *visit(XORN_operator_c *symbol) { - if (search_expression_type->is_binary_type(this->default_variable_name.current_type) && - search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { - XXX_operator(&(this->default_variable_name), - // bit by bit exclusive OR !! Also seems to work with boolean types! - search_expression_type->is_bool_type(this->current_operand_type)?" ^= !":" ^= ~", - this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - } - else {ERROR;} - return NULL; -} - -void *visit(ADD_operator_c *symbol) { - if (search_expression_type->is_time_type(this->default_variable_name.current_type) && - search_expression_type->is_time_type(this->current_operand_type)) { - XXX_function("__time_add", &(this->default_variable_name), this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - return NULL; - } - if (search_expression_type->is_num_type(this->default_variable_name.current_type) && - search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { - XXX_operator(&(this->default_variable_name), " += ", this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - return NULL; - } - ERROR; - return NULL; -} - -void *visit(SUB_operator_c *symbol) { - if (search_expression_type->is_time_type(this->default_variable_name.current_type) && - search_expression_type->is_time_type(this->current_operand_type)) { - XXX_function("__time_sub", &(this->default_variable_name), this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - return NULL; - } - if (search_expression_type->is_num_type(this->default_variable_name.current_type) && - search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { - XXX_operator(&(this->default_variable_name), " -= ", this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - return NULL; - } - ERROR; - return NULL; -} - -void *visit(MUL_operator_c *symbol) { - if (search_expression_type->is_time_type(this->default_variable_name.current_type) && - search_expression_type->is_integer_type(this->current_operand_type)) { - XXX_function("__time_mul", &(this->default_variable_name), this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - return NULL; - } - if (search_expression_type->is_num_type(this->default_variable_name.current_type) && - search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { - XXX_operator(&(this->default_variable_name), " *= ", this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - return NULL; - } - ERROR; - return NULL; -} - -void *visit(DIV_operator_c *symbol) { - if (search_expression_type->is_num_type(this->default_variable_name.current_type) && - search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { - XXX_operator(&(this->default_variable_name), " /= ", this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - } - else {ERROR;} - return NULL; -} - -void *visit(MOD_operator_c *symbol) { - if (search_expression_type->is_num_type(this->default_variable_name.current_type) && - search_expression_type->is_same_type(this->default_variable_name.current_type, this->current_operand_type)) { - XXX_operator(&(this->default_variable_name), " %= ", this->current_operand); - /* the data type resulting from this operation... */ - this->default_variable_name.current_type = this->current_operand_type; - } - else {ERROR;} - return NULL; -} - -void *visit(GT_operator_c *symbol) { - return CMP_operator(this->current_operand, "__gt_"); -} - -void *visit(GE_operator_c *symbol) { - return CMP_operator(this->current_operand, "__ge_"); -} - -void *visit(EQ_operator_c *symbol) { - return CMP_operator(this->current_operand, "__eq_"); -} - -void *visit(LT_operator_c *symbol) { - return CMP_operator(this->current_operand, "__lt_"); -} - -void *visit(LE_operator_c *symbol) { - return CMP_operator(this->current_operand, "__le_"); -} - -void *visit(NE_operator_c *symbol) { - return CMP_operator(this->current_operand, "__ne_"); -} - - -//SYM_REF0(CAL_operator_c) -// This method will be called from within the il_fb_call_c visitor method -void *visit(CAL_operator_c *symbol) {return NULL;} - -//SYM_REF0(CALC_operator_c) -// This method will be called from within the il_fb_call_c visitor method -void *visit(CALC_operator_c *symbol) {C_modifier(); return NULL;} - -//SYM_REF0(CALCN_operator_c) -// This method will be called from within the il_fb_call_c visitor method -void *visit(CALCN_operator_c *symbol) {CN_modifier(); return NULL;} - -/* NOTE: The semantics of the RET operator requires us to return a value - * if the IL code is inside a function, but simply return no value if - * the IL code is inside a function block or program! - * Nevertheless, it is the generate_cc_c class itself that - * introduces the 'reaturn ' into the c++ code at the end - * of every function. This class does not know whether the IL code - * is inside a function or a function block. - * We work around this by jumping to the end of the code, - * that will be marked by the END_LABEL label in the - * instruction_list_c visitor... - */ -// SYM_REF0(RET_operator_c) -void *visit(RET_operator_c *symbol) { - s4o.print("goto ");s4o.print(END_LABEL); - return NULL; -} - -// SYM_REF0(RETC_operator_c) -void *visit(RETC_operator_c *symbol) { - C_modifier(); - s4o.print("goto ");s4o.print(END_LABEL); - return NULL; -} - -// SYM_REF0(RETCN_operator_c) -void *visit(RETCN_operator_c *symbol) { - CN_modifier(); - s4o.print("goto ");s4o.print(END_LABEL); - return NULL; -} - -//SYM_REF0(JMP_operator_c) -void *visit(JMP_operator_c *symbol) { - if (NULL == this->jump_label) ERROR; - - s4o.print("goto "); - this->jump_label->accept(*this); - /* the data type resulting from this operation is unchanged! */ - return NULL; -} - -// SYM_REF0(JMPC_operator_c) -void *visit(JMPC_operator_c *symbol) { - if (NULL == this->jump_label) ERROR; - - C_modifier(); - s4o.print("goto "); - this->jump_label->accept(*this); - /* the data type resulting from this operation is unchanged! */ - return NULL; -} - -// SYM_REF0(JMPCN_operator_c) -void *visit(JMPCN_operator_c *symbol) { - if (NULL == this->jump_label) ERROR; - - CN_modifier(); - s4o.print("goto "); - this->jump_label->accept(*this); - /* the data type resulting from this operation is unchanged! */ - return NULL; -} - -#if 0 -/*| [NOT] any_identifier SENDTO */ -SYM_REF2(il_assign_out_operator_c, option, variable_name) -#endif - -}; /* generate_cc_il_c */ - - - - - - - - - -/* The implementation of the single visit() member function - * of il_default_variable_c. - * It can only come after the full declaration of - * generate_cc_il_c. Since we define and declare - * generate_cc_il_c simultaneously, it can only come - * after the definition... - */ -void *il_default_variable_c::accept(visitor_c &visitor) { - /* An ugly hack!! */ - /* This is required because we need to over-ride the base - * accept(visitor_c &) method of the class symbol_c, - * so this method may be called through a symbol_c * - * reference! - * - * But, the visitor_c does not include a visitor to - * an il_default_variable_c, which means that we couldn't - * simply call visitor.visit(this); - * - * We therefore need to use the dynamic_cast hack!! - * - * Note too that we can't cast a visitor_c to a - * il_default_variable_visitor_c, since they are not related. - * Nor may the il_default_variable_visitor_c inherit from - * visitor_c, because then generate_cc_il_c would contain - * two visitor_c base classes, one each through - * il_default_variable_visitor_c and generate_cc_type_c - * - * We could use virtual inheritance of the visitor_c, but it - * would probably create more problems than it is worth! - */ - generate_cc_il_c *v; - v = dynamic_cast(&visitor); - if (v == NULL) ERROR; - - return v->visit(this); -} - - - - -il_default_variable_c::il_default_variable_c(const char *var_name_str, symbol_c *current_type) { - if (NULL == var_name_str) ERROR; - /* Note: current_type may start off with NULL */ - - this->var_name = new identifier_c(var_name_str); - if (NULL == this->var_name) ERROR; - - this->current_type = current_type; -} diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/generate_cc_sfc.cc --- a/stage4/generate_cc/generate_cc_sfc.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,736 +0,0 @@ -/* - * (c) 2007 Mario de Sousa, Laurent Bessard - * - * 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) - * - */ - - -/* - * Conversion of sfc networks (i.e. SFC code). - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the SFC, IL and ST - * code. - */ - -#include - -typedef struct -{ - transition_c *symbol; - int priority; - int index; -} TRANSITION; - - - - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - -class generate_cc_sfc_elements_c: public generate_cc_base_c { - - public: - typedef enum { - transitionlist_sg, - transitiontest_sg, - stepset_sg, - stepreset_sg, - actionassociation_sg, - actionbody_sg - } sfcgeneration_t; - - private: - generate_cc_il_c *generate_cc_il; - generate_cc_st_c *generate_cc_st; - generate_cc_SFC_IL_ST_c *generate_cc_code; - search_var_instance_decl_c *search_var_instance_decl; - - int transition_number; - std::list transition_list; - - symbol_c *current_step; - symbol_c *current_action; - - sfcgeneration_t wanted_sfcgeneration; - - public: - generate_cc_sfc_elements_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) - : generate_cc_base_c(s4o_ptr) { - generate_cc_il = new generate_cc_il_c(s4o_ptr, scope, variable_prefix); - generate_cc_st = new generate_cc_st_c(s4o_ptr, scope, variable_prefix); - generate_cc_code = new generate_cc_SFC_IL_ST_c(s4o_ptr, scope, variable_prefix); - search_var_instance_decl = new search_var_instance_decl_c(scope); - this->set_variable_prefix(variable_prefix); - } - - ~generate_cc_sfc_elements_c(void) { - delete generate_cc_il; - delete generate_cc_st; - delete generate_cc_code; - delete search_var_instance_decl; - } - - void reset_transition_number(void) {transition_number = 0;} - - void generate(symbol_c *symbol, sfcgeneration_t generation_type) { - wanted_sfcgeneration = generation_type; - switch (wanted_sfcgeneration) { - case transitiontest_sg: - { - std::list::iterator pt; - for(pt = transition_list.begin(); pt != transition_list.end(); pt++) { - transition_number = pt->index; - pt->symbol->accept(*this); - } - } - break; - default: - symbol->accept(*this); - break; - } - } - - void print_step_argument(symbol_c *step_name, const char* argument) { - print_variable_prefix(); - s4o.print("step_list["); - s4o.print(SFC_STEP_ACTION_PREFIX); - step_name->accept(*this); - s4o.print("]."); - s4o.print(argument); - } - - void print_action_argument(symbol_c *action_name, const char* argument) { - print_variable_prefix(); - s4o.print("action_list["); - s4o.print(SFC_STEP_ACTION_PREFIX); - action_name->accept(*this); - s4o.print("]."); - s4o.print(argument); - } - - void print_transition_number(void) { - char str[10]; - sprintf(str, "%d", transition_number); - s4o.print(str); - } - - void print_reset_step(symbol_c *step_name) { - s4o.print(s4o.indent_spaces); - print_step_argument(step_name, "state"); - s4o.print(" = 0;\n"); - } - - void print_set_step(symbol_c *step_name) { - s4o.print(s4o.indent_spaces); - print_step_argument(step_name, "state"); - s4o.print(" = 1;\n" + s4o.indent_spaces); - print_step_argument(step_name, "elapsed_time"); - s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); - } - - bool is_variable(symbol_c *symbol) { - /* we try to find the variable instance declaration, to determine its type... */ - symbol_c *var_decl = search_var_instance_decl->get_decl(symbol); - - return var_decl != NULL; - } - -/*********************************************/ -/* B.1.6 Sequential function chart elements */ -/*********************************************/ - - void *visit(initial_step_c *symbol) { - switch (wanted_sfcgeneration) { - case actionassociation_sg: - if (((list_c*)symbol->action_association_list)->n > 0) { - s4o.print(s4o.indent_spaces + "// "); - symbol->step_name->accept(*this); - s4o.print(" action associations\n"); - current_step = symbol->step_name; - s4o.print(s4o.indent_spaces + "{\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces + "char activated = "); - print_step_argument(current_step, "state"); - s4o.print(" && !"); - print_step_argument(current_step, "prev_state"); - s4o.print(";\n"); - s4o.print(s4o.indent_spaces + "char desactivated = !"); - print_step_argument(current_step, "state"); - s4o.print(" && "); - print_step_argument(current_step, "prev_state"); - s4o.print(";\n"); - s4o.print(s4o.indent_spaces + "char active = "); - print_step_argument(current_step, "state"); - s4o.print(";\n"); - symbol->action_association_list->accept(*this); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n\n"); - } - break; - default: - break; - } - return NULL; - } - - void *visit(step_c *symbol) { - switch (wanted_sfcgeneration) { - case actionassociation_sg: - if (((list_c*)symbol->action_association_list)->n > 0) { - s4o.print(s4o.indent_spaces + "// "); - symbol->step_name->accept(*this); - s4o.print(" action associations\n"); - current_step = symbol->step_name; - s4o.print(s4o.indent_spaces + "{\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces + "char activated = "); - print_step_argument(current_step, "state"); - s4o.print(" && !"); - print_step_argument(current_step, "prev_state"); - s4o.print(";\n"); - s4o.print(s4o.indent_spaces + "char desactivated = !"); - print_step_argument(current_step, "state"); - s4o.print(" && "); - print_step_argument(current_step, "prev_state"); - s4o.print(";\n"); - s4o.print(s4o.indent_spaces + "char active = "); - print_step_argument(current_step, "state"); - s4o.print(";\n"); - symbol->action_association_list->accept(*this); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n\n"); - } - break; - default: - break; - } - return NULL; - } - - void *visit(transition_c *symbol) { - switch (wanted_sfcgeneration) { - case transitionlist_sg: - { - TRANSITION *transition; - transition = new TRANSITION; - transition->symbol = symbol; - transition->index = transition_number; - if (symbol->integer != NULL) { - transition->priority = atoi(((token_c *)symbol->integer)->value); - std::list::iterator pt = transition_list.begin(); - while (pt != transition_list.end() && pt->priority <= transition->priority) { - pt++; - } - transition_list.insert(pt, *transition); - } - else { - transition->priority = 0; - transition_list.push_back(*transition); - } - transition_number++; - } - break; - case transitiontest_sg: - s4o.print(s4o.indent_spaces + "if ("); - symbol->from_steps->accept(*this); - s4o.print(") {\n"); - s4o.indent_right(); - - // Calculate transition value - if (symbol->transition_condition_il != NULL) { - generate_cc_il->declare_backup_variable(); - s4o.print(s4o.indent_spaces); - symbol->transition_condition_il->accept(*generate_cc_il); - print_variable_prefix(); - s4o.print("transition_list["); - print_transition_number(); - s4o.print("] = "); - generate_cc_il->print_backup_variable(); - s4o.print(";\n"); - } - if (symbol->transition_condition_st != NULL) { - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("transition_list["); - print_transition_number(); - s4o.print("] = "); - symbol->transition_condition_st->accept(*generate_cc_st); - s4o.print(";\n"); - } - if (symbol->integer != NULL) { - s4o.print(s4o.indent_spaces + "if ("); - print_variable_prefix(); - s4o.print("transition_list["); - print_transition_number(); - s4o.print("]) {\n"); - s4o.indent_right(); - wanted_sfcgeneration = stepreset_sg; - symbol->from_steps->accept(*this); - wanted_sfcgeneration = transitiontest_sg; - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - } - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces + "else {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("transition_list["); - print_transition_number(); - s4o.print("] = 0;\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - break; - case stepset_sg: - s4o.print(s4o.indent_spaces + "if ("); - print_variable_prefix(); - s4o.print("transition_list["); - print_transition_number(); - s4o.print("]) {\n"); - s4o.indent_right(); - symbol->to_steps->accept(*this); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - transition_number++; - break; - case stepreset_sg: - if (symbol->integer == NULL) { - s4o.print(s4o.indent_spaces + "if ("); - print_variable_prefix(); - s4o.print("transition_list["); - print_transition_number(); - s4o.print("]) {\n"); - s4o.indent_right(); - symbol->from_steps->accept(*this); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - } - transition_number++; - break; - default: - break; - } - return NULL; - } - - void *visit(action_c *symbol) { - switch (wanted_sfcgeneration) { - case actionbody_sg: - s4o.print(s4o.indent_spaces + "if("); - print_variable_prefix(); - s4o.print("action_list["); - s4o.print(SFC_STEP_ACTION_PREFIX); - symbol->action_name->accept(*this); - s4o.print("].state) {"); - s4o.indent_right(); - - // generate action code - symbol->function_block_body->accept(*generate_cc_code); - - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n\n"); - break; - default: - break; - } - return NULL; - } - - void *visit(steps_c *symbol) { - if (symbol->step_name != NULL) { - switch (wanted_sfcgeneration) { - case transitiontest_sg: - print_step_argument(symbol->step_name, "state"); - break; - case stepset_sg: - print_set_step(symbol->step_name); - break; - case stepreset_sg: - print_reset_step(symbol->step_name); - break; - default: - break; - } - } - else if (symbol->step_name_list != NULL) { - symbol->step_name_list->accept(*this); - } - return NULL; - } - - void *visit(step_name_list_c *symbol) { - switch (wanted_sfcgeneration) { - case transitiontest_sg: - for(int i = 0; i < symbol->n; i++) { - print_step_argument(symbol->elements[i], "state"); - if (i < symbol->n - 1) { - s4o.print(" && "); - } - } - break; - case stepset_sg: - for(int i = 0; i < symbol->n; i++) { - print_set_step(symbol->elements[i]); - } - break; - case stepreset_sg: - for(int i = 0; i < symbol->n; i++) { - print_reset_step(symbol->elements[i]); - } - break; - default: - break; - } - return NULL; - } - - void *visit(action_association_list_c* symbol) { - switch (wanted_sfcgeneration) { - case actionassociation_sg: - print_list(symbol, "", "\n", "\n"); - break; - default: - break; - } - return NULL; - } - - void *visit(action_association_c *symbol) { - switch (wanted_sfcgeneration) { - case actionassociation_sg: - if (symbol->action_qualifier != NULL) { - current_action = symbol->action_name; - symbol->action_qualifier->accept(*this); - } - else { - s4o.print(s4o.indent_spaces + "if ("); - print_step_argument(current_step, "state"); - s4o.print(") {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_action_argument(symbol->action_name, "state"); - s4o.print(" = 1;\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}"); - } - break; - default: - break; - } - return NULL; - } - - void *visit(action_qualifier_c *symbol) { - switch (wanted_sfcgeneration) { - case actionassociation_sg: - { - char *qualifier = (char *)symbol->action_qualifier->accept(*this); - s4o.print(s4o.indent_spaces + "if ("); - if (strcmp(qualifier, "N") == 0) { - s4o.print("active"); - } - if (strcmp(qualifier, "P") == 0 || strcmp(qualifier, "SD") == 0 || - strcmp(qualifier, "DS") == 0 || strcmp(qualifier, "SL") == 0 || - strcmp(qualifier, "S") == 0 || strcmp(qualifier, "R") == 0) { - s4o.print("activated"); - } - if (strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) { - s4o.print("active && "); - print_step_argument(current_step, "elapsed_time"); - if (strcmp(qualifier, "D") == 0) { - s4o.print(" >= "); - } - else { - s4o.print(" < "); - } - symbol->action_time->accept(*this); - } - s4o.print(") {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - if (strcmp(qualifier, "N") == 0 || strcmp(qualifier, "P") == 0 || - strcmp(qualifier, "D") == 0 || strcmp(qualifier, "L") == 0) { - print_action_argument(current_action, "state"); - s4o.print(" = 1;\n"); - } - if (strcmp(qualifier, "S") == 0) { - if (is_variable(current_action)) { - print_variable_prefix(); - current_action->accept(*this); - } - else - print_action_argument(current_action, "set"); - s4o.print(" = 1;\n"); - } - if (strcmp(qualifier, "R") == 0) { - if (is_variable(current_action)) { - print_variable_prefix(); - current_action->accept(*this); - s4o.print(" = 0;\n"); - } - else { - print_action_argument(current_action, "reset"); - s4o.print(" = 1;\n"); - } - } - if (strcmp(qualifier, "SD") == 0 || strcmp(qualifier, "DS") == 0 || - strcmp(qualifier, "SL") == 0) { - if (strcmp(qualifier, "SL") == 0) { - print_action_argument(current_action, "reset_remaining_time"); - } - else { - print_action_argument(current_action, "set_remaining_time"); - } - s4o.print(" = "); - symbol->action_time->accept(*this); - s4o.print(";\n"); - } - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}"); - if (strcmp(qualifier, "DS") == 0) { - s4o.print("desactivated"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_action_argument(current_action, "set_remaining_time"); - s4o.print(" = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); - } - } - break; - default: - break; - } - return NULL; - } - - void *visit(qualifier_c *symbol) { - return (void *)symbol->value; - } - - void *visit(timed_qualifier_c *symbol) { - return (void *)symbol->value; - } - -}; /* generate_cc_sfc_actiondecl_c */ - - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - -class generate_cc_sfc_c: public generate_cc_typedecl_c { - - private: - generate_cc_sfc_elements_c *generate_cc_sfc_elements; - - public: - generate_cc_sfc_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) - : generate_cc_typedecl_c(s4o_ptr) { - generate_cc_sfc_elements = new generate_cc_sfc_elements_c(s4o_ptr, scope, variable_prefix); - this->set_variable_prefix(variable_prefix); - } - - virtual ~generate_cc_sfc_c(void) { - delete generate_cc_sfc_elements; - } - -/*********************************************/ -/* B.1.6 Sequential function chart elements */ -/*********************************************/ - - void *visit(sfc_network_c *symbol) { - generate_cc_sfc_elements->generate((symbol_c *) symbol, generate_cc_sfc_elements_c::transitionlist_sg); - s4o.print(s4o.indent_spaces +"INT i;\n\n"); - s4o.print(s4o.indent_spaces +"BOOL transition;\n\n"); - - /* generate step initilizations */ - s4o.print(s4o.indent_spaces + "// Steps initialisation\n"); - s4o.print(s4o.indent_spaces + "for (i = 0; i < "); - print_variable_prefix(); - s4o.print("nb_steps; i++) {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("step_list[i].prev_state = "); - print_variable_prefix(); - s4o.print("step_list[i].state;\n"); - s4o.print(s4o.indent_spaces + "if ("); - print_variable_prefix(); - s4o.print("step_list[i].state) {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("step_list[i].elapsed_time = __time_add("); - print_variable_prefix(); - s4o.print("step_list[i].elapsed_time, "); - print_variable_prefix(); - s4o.print("period);\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - - /* generate action initilizations */ - s4o.print(s4o.indent_spaces + "// Actions initialisation\n"); - s4o.print(s4o.indent_spaces + "for (i = 0; i < "); - print_variable_prefix(); - s4o.print("nb_actions; i++) {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].state = 0;\n"); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].set = 0;\n"); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].reset = 0;\n"); - s4o.print(s4o.indent_spaces + "if ("); - s4o.print("__gt_TIME(2, "); - print_variable_prefix(); - s4o.print("action_list[i].set_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0))) {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].set_remaining_time = __time_sub("); - print_variable_prefix(); - s4o.print("action_list[i].set_remaining_time, "); - print_variable_prefix(); - s4o.print("period);\n"); - s4o.print(s4o.indent_spaces + "if ("); - s4o.print("__le_TIME(2, "); - print_variable_prefix(); - s4o.print("action_list[i].set_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0))) {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].set_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].set = 1;\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - s4o.print(s4o.indent_spaces + "if ("); - s4o.print("__gt_TIME(2, "); - print_variable_prefix(); - s4o.print("action_list[i].reset_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0))) {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].reset_remaining_time = __time_sub("); - print_variable_prefix(); - s4o.print("action_list[i].reset_remaining_time, "); - print_variable_prefix(); - s4o.print("period);\n"); - s4o.print(s4o.indent_spaces + "if ("); - s4o.print("__le_TIME(2, "); - print_variable_prefix(); - s4o.print("action_list[i].reset_remaining_time, __time_to_timespec(1, 0, 0, 0, 0, 0))) {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].reset_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].reset = 1;\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n\n"); - - /* generate transition tests */ - s4o.print(s4o.indent_spaces + "// Transitions fire test\n"); - generate_cc_sfc_elements->generate((symbol_c *) symbol, generate_cc_sfc_elements_c::transitiontest_sg); - s4o.print("\n"); - - /* generate transition reset steps */ - s4o.print(s4o.indent_spaces + "// Transitions reset steps\n"); - generate_cc_sfc_elements->reset_transition_number(); - generate_cc_sfc_elements->generate((symbol_c *) symbol, generate_cc_sfc_elements_c::stepreset_sg); - s4o.print("\n"); - - /* generate transition set steps */ - s4o.print(s4o.indent_spaces + "// Transitions set steps\n"); - generate_cc_sfc_elements->reset_transition_number(); - generate_cc_sfc_elements->generate((symbol_c *) symbol, generate_cc_sfc_elements_c::stepset_sg); - s4o.print("\n"); - - /* generate step association */ - s4o.print(s4o.indent_spaces + "// Steps association\n"); - generate_cc_sfc_elements->generate((symbol_c *) symbol, generate_cc_sfc_elements_c::actionassociation_sg); - s4o.print("\n"); - - /* generate action state evaluation */ - s4o.print(s4o.indent_spaces + "// Actions state evaluation\n"); - s4o.print(s4o.indent_spaces + "for (i = 0; i < "); - print_variable_prefix(); - s4o.print("nb_actions; i++) {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces + "if ("); - print_variable_prefix(); - s4o.print("action_list[i].set) {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].stored = 1;\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces + "if ("); - print_variable_prefix(); - s4o.print("action_list[i].reset) {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].set_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n" + s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].reset_remaining_time = __time_to_timespec(1, 0, 0, 0, 0, 0);\n" + s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].stored = 0;\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n" + s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i].state |= "); - print_variable_prefix(); - s4o.print("action_list[i].stored;\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n\n"); - - /* generate action execution */ - s4o.print(s4o.indent_spaces + "// Actions execution\n"); - generate_cc_sfc_elements->generate((symbol_c *) symbol, generate_cc_sfc_elements_c::actionbody_sg); - s4o.print("\n"); - - return NULL; - } - - void generate(sequential_function_chart_c *sfc) { - sfc->accept(*this); - } - -}; /* generate_cc_sfc_c */ diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/generate_cc_sfcdecl.cc --- a/stage4/generate_cc/generate_cc_sfcdecl.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,308 +0,0 @@ -/* - * (c) 2007 Mario de Sousa, Laurent Bessard - * - * 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) - * - */ - - -/* - * Conversion of sfc networks (i.e. SFC code). - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the SFC, IL and ST - * code. - */ - - - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - -class generate_cc_sfcdecl_c: protected generate_cc_typedecl_c { - - public: - typedef enum { - sfcdecl_sd, - sfcinit_sd, - stepcount_sd, - stepdef_sd, - stepundef_sd, - actiondef_sd, - actionundef_sd, - actioncount_sd - } sfcdeclaration_t; - - private: - char step_number; - char action_number; - char transition_number; - - sfcdeclaration_t wanted_sfcdeclaration; - - public: - generate_cc_sfcdecl_c(stage4out_c *s4o_ptr, sfcdeclaration_t sfcdeclaration) - : generate_cc_typedecl_c(s4o_ptr) { - wanted_sfcdeclaration = sfcdeclaration; - } - ~generate_cc_sfcdecl_c(void) {} - - void print(symbol_c *symbol, const char *variable_prefix = NULL) { - this->set_variable_prefix(variable_prefix); - - symbol->accept(*this); - } - -/*********************************************/ -/* B.1.6 Sequential function chart elements */ -/*********************************************/ - - void *visit(sequential_function_chart_c *symbol) { - step_number = 0; - action_number = 0; - transition_number = 0; - switch (wanted_sfcdeclaration) { - case sfcdecl_sd: - for(int i = 0; i < symbol->n; i++) - symbol->elements[i]->accept(*this); - - /* steps table declaration */ - s4o.print(s4o.indent_spaces + "STEP step_list["); - s4o.print_integer(step_number); - s4o.print("];\n"); - s4o.print(s4o.indent_spaces + "UINT nb_steps;\n"); - - /* actions table declaration */ - s4o.print(s4o.indent_spaces + "ACTION action_list["); - s4o.print_integer(action_number); - s4o.print("];\n"); - s4o.print(s4o.indent_spaces + "UINT nb_actions;\n"); - - /* transitions table declaration */ - s4o.print(s4o.indent_spaces + "USINT transition_list["); - s4o.print_integer(transition_number); - s4o.print("];\n"); - - /* period declaration */ - s4o.print(s4o.indent_spaces + "TIME period;\n"); - break; - case sfcinit_sd: - s4o.print(s4o.indent_spaces); - s4o.print("UINT i;\n"); - - /* steps table count */ - wanted_sfcdeclaration = stepcount_sd; - for(int i = 0; i < symbol->n; i++) - symbol->elements[i]->accept(*this); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("nb_steps = "); - s4o.print_integer(step_number); - s4o.print(";\n"); - step_number = 0; - wanted_sfcdeclaration = sfcinit_sd; - - /* steps table initialisation */ - s4o.print(s4o.indent_spaces + "STEP temp_step = {0, 0, 0};\n"); - s4o.print(s4o.indent_spaces + "for(i = 0; i < "); - print_variable_prefix(); - s4o.print("nb_steps; i++) {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("step_list[i] = temp_step;\n"); - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - for(int i = 0; i < symbol->n; i++) - symbol->elements[i]->accept(*this); - - /* steps table count */ - wanted_sfcdeclaration = actioncount_sd; - for(int i = 0; i < symbol->n; i++) - symbol->elements[i]->accept(*this); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("nb_actions = "); - s4o.print_integer(action_number); - s4o.print(";\n"); - action_number = 0; - wanted_sfcdeclaration = sfcinit_sd; - - /* actions table initialisation */ - s4o.print(s4o.indent_spaces + "ACTION temp_action = {0, 0, 0, 0, 0, 0};\n"); - s4o.print(s4o.indent_spaces + "for(i = 0; i < "); - print_variable_prefix(); - s4o.print("nb_actions; i++) {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("action_list[i] = temp_action;\n"); - - /* period initialisation */ - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("period = __time_to_timespec(1, 0, 0, 0, 0, 0);\n"); - - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}\n"); - break; - case stepdef_sd: - s4o.print("// Steps definitions\n"); - for(int i = 0; i < symbol->n; i++) - symbol->elements[i]->accept(*this); - s4o.print("\n"); - break; - case actiondef_sd: - s4o.print("// Actions definitions\n"); - for(int i = 0; i < symbol->n; i++) - symbol->elements[i]->accept(*this); - s4o.print("\n"); - break; - case stepundef_sd: - s4o.print("// Steps undefinitions\n"); - for(int i = 0; i < symbol->n; i++) - symbol->elements[i]->accept(*this); - s4o.print("\n"); - break; - case actionundef_sd: - s4o.print("// Actions undefinitions\n"); - for(int i = 0; i < symbol->n; i++) - symbol->elements[i]->accept(*this); - s4o.print("\n"); - break; - default: - break; - } - return NULL; - } - - void *visit(initial_step_c *symbol) { - switch (wanted_sfcdeclaration) { - case stepcount_sd: - case sfcdecl_sd: - step_number++; - break; - case sfcinit_sd: - s4o.print(s4o.indent_spaces); - print_variable_prefix(); - s4o.print("step_list["); - s4o.print_integer(step_number); - s4o.print("].state = 1;\n"); - step_number++; - break; - case stepdef_sd: - s4o.print("#define "); - s4o.print(SFC_STEP_ACTION_PREFIX); - symbol->step_name->accept(*this); - s4o.print(" "); - s4o.print_integer(step_number); - s4o.print("\n"); - step_number++; - break; - case stepundef_sd: - s4o.print("#undef "); - s4o.print(SFC_STEP_ACTION_PREFIX); - symbol->step_name->accept(*this); - s4o.print("\n"); - break; - default: - break; - } - return NULL; - } - - void *visit(step_c *symbol) { - switch (wanted_sfcdeclaration) { - case stepcount_sd: - case sfcdecl_sd: - step_number++; - break; - case stepdef_sd: - s4o.print("#define "); - s4o.print(SFC_STEP_ACTION_PREFIX); - symbol->step_name->accept(*this); - s4o.print(" "); - s4o.print_integer(step_number); - s4o.print("\n"); - step_number++; - break; - case stepundef_sd: - s4o.print("#undef "); - s4o.print(SFC_STEP_ACTION_PREFIX); - symbol->step_name->accept(*this); - s4o.print("\n"); - break; - default: - break; - } - return NULL; - } - - void *visit(transition_c *symbol) { - switch (wanted_sfcdeclaration) { - case sfcdecl_sd: - transition_number++; - break; - default: - break; - } - return NULL; - } - - void *visit(action_c *symbol) { - switch (wanted_sfcdeclaration) { - case actiondef_sd: - s4o.print("#define "); - s4o.print(SFC_STEP_ACTION_PREFIX); - symbol->action_name->accept(*this); - s4o.print(" "); - s4o.print_integer(action_number); - s4o.print("\n"); - action_number++; - break; - case actionundef_sd: - s4o.print("#undef "); - s4o.print(SFC_STEP_ACTION_PREFIX); - symbol->action_name->accept(*this); - s4o.print("\n"); - break; - case actioncount_sd: - case sfcdecl_sd: - action_number++; - break; - default: - break; - } - return NULL; - } - - void *visit(instruction_list_c *symbol) { - return NULL; - } - - void *visit(statement_list_c *symbol) { - return NULL; - } - -}; /* generate_cc_sfcdecl_c */ - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/generate_cc_st.cc --- a/stage4/generate_cc/generate_cc_st.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,847 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * Conversion of st statements (i.e. ST code). - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the IL and ST - * code. - */ - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - - -class generate_cc_st_c: public generate_cc_typedecl_c { - - private: - /* When calling a function block, we must first find it's type, - * by searching through the declarations of the variables currently - * in scope. - * This class does just that... - * A new class is instantiated whenever we begin generating the code - * for a function block type declaration, or a program declaration. - * This object instance will then later be called while the - * function block's or the program's body is being handled. - * - * Note that functions cannot contain calls to function blocks, - * so we do not create an object instance when handling - * a function declaration. - */ - search_fb_instance_decl_c *search_fb_instance_decl; - - /* When compiling st code, it becomes necessary to determine the - * data type of st expressions. To do this, we must first find the - * st operand's declaration, within the scope of the function block - * or function currently being processed. - * The following object does just that... - * This object instance will then later be called while the - * remaining st code is being handled. - */ - search_expression_type_c *search_expression_type; - - search_varfb_instance_type_c *search_varfb_instance_type; - - public: - generate_cc_st_c(stage4out_c *s4o_ptr, symbol_c *scope, const char *variable_prefix = NULL) - : generate_cc_typedecl_c(s4o_ptr) { - search_fb_instance_decl = new search_fb_instance_decl_c(scope); - search_expression_type = new search_expression_type_c(scope); - search_varfb_instance_type = new search_varfb_instance_type_c(scope); - this->set_variable_prefix(variable_prefix); - } - - virtual ~generate_cc_st_c(void) { - delete search_fb_instance_decl; - delete search_expression_type; - delete search_varfb_instance_type; - } - - - private: - /* Some function calls in the body of functions or function blocks - * may leave some parameters to their default values, and - * ignore some output parameters of the function being called. - * Our conversion of ST functions to C++ does not contemplate that, - * i.e. each called function must get all it's input and output - * parameters set correctly. - * For input parameters we merely need to call the function with - * the apropriate default value, but for output parameters - * we must create temporary variables to hold the output value. - * - * We declare all the temporary output variables at the begining of - * the body of each function or function block, and use them as - * in function calls later on as they become necessary... - * Note that we cannot create these variables just before a function - * call, as the function call itself may be integrated within an - * expression, or another function call! - * - * The variables are declared in the exact same order in which they - * will be used later on during the function calls, which allows us - * to simply re-create the name that was used for the temporary variable - * instead of keeping it in some list. - * The names are recreated by the temp_var_name_factory, after reset() - * has been called! - * - * This function will genertae code similar to... - * - * INT __TMP_0 = 23; - * REAL __TMP_1 = 45.5; - * ... - */ - temp_var_name_c temp_var_name_factory; - - public: - void generate(statement_list_c *stl) { - generate_cc_tempvardecl_c generate_cc_tempvardecl(&s4o); - generate_cc_tempvardecl.generate(stl, &temp_var_name_factory); - stl->accept(*this); - } - - private: - -/*********************/ -/* B 1.4 - Variables */ -/*********************/ -void *visit(symbolic_variable_c *symbol) { - unsigned int vartype = search_varfb_instance_type->get_vartype(symbol); - if (vartype == search_var_instance_decl_c::external_vt || vartype == search_var_instance_decl_c::located_vt) { - s4o.print("*("); - generate_cc_base_c::visit(symbol); - s4o.print(")"); - } - else { - generate_cc_base_c::visit(symbol); - } - return NULL; -} - -/********************************************/ -/* B.1.4.1 Directly Represented Variables */ -/********************************************/ -// direct_variable: direct_variable_token {$$ = new direct_variable_c($1);}; -void *visit(direct_variable_c *symbol) { - TRACE("direct_variable_c"); - /* Do not use print_token() as it will change everything into uppercase */ - if (strlen(symbol->value) == 0) ERROR; - s4o.print("*("); - this->print_variable_prefix(); - s4o.printlocation(symbol->value + 1); - s4o.print(")"); - return NULL; -} - -/***************************************/ -/* B.3 - Language ST (Structured Text) */ -/***************************************/ -/***********************/ -/* B 3.1 - Expressions */ -/***********************/ -void *visit(or_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_bool_type(left_type)) - return print_binary_expression(symbol->l_exp, symbol->r_exp, " || "); - if (search_expression_type->is_binary_type(left_type)) - return print_binary_expression(symbol->l_exp, symbol->r_exp, " | "); - ERROR; - return NULL; -} - -void *visit(xor_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_bool_type(left_type)) { - s4o.print("("); - symbol->l_exp->accept(*this); - s4o.print(" && !"); - symbol->r_exp->accept(*this); - s4o.print(") || (!"); - symbol->l_exp->accept(*this); - s4o.print(" && "); - symbol->r_exp->accept(*this); - s4o.print(")"); - } - if (search_expression_type->is_binary_type(left_type)) - return print_binary_expression(symbol->l_exp, symbol->r_exp, " ^ "); - ERROR; - return NULL; -} - -void *visit(and_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_bool_type(left_type)) - return print_binary_expression(symbol->l_exp, symbol->r_exp, " && "); - if (search_expression_type->is_binary_type(left_type)) - return print_binary_expression(symbol->l_exp, symbol->r_exp, " & "); - ERROR; - return NULL; -} - -void *visit(equ_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_time_type(left_type)) - return print_compare_function("__eq_", left_type, symbol->l_exp, symbol->r_exp); - return print_binary_expression(symbol->l_exp, symbol->r_exp, " == "); -} - -void *visit(notequ_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_time_type(left_type)) - return print_compare_function("__ne_", left_type, symbol->l_exp, symbol->r_exp); - return print_binary_expression(symbol->l_exp, symbol->r_exp, " != "); -} - -void *visit(lt_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_time_type(left_type)) - return print_compare_function("__lt_", left_type, symbol->l_exp, symbol->r_exp); - return print_binary_expression(symbol->l_exp, symbol->r_exp, " < "); -} - -void *visit(gt_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_time_type(left_type)) - return print_compare_function("__gt_", left_type, symbol->l_exp, symbol->r_exp); - return print_binary_expression(symbol->l_exp, symbol->r_exp, " > "); -} - -void *visit(le_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_time_type(left_type)) - return print_compare_function("__le_", left_type, symbol->l_exp, symbol->r_exp); - return print_binary_expression(symbol->l_exp, symbol->r_exp, " <= "); -} - -void *visit(ge_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_time_type(left_type)) - return print_compare_function("__ge_", left_type, symbol->l_exp, symbol->r_exp); - return print_binary_expression(symbol->l_exp, symbol->r_exp, " >= "); -} - -void *visit(add_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) || - (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) || - (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c))) - return print_binary_function("__time_add", symbol->l_exp, symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type)) - return print_binary_expression(symbol->l_exp, symbol->r_exp, " + "); - ERROR; - return NULL; -} - -void *visit(sub_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if ((typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) || - (typeid(*left_type) == typeid(date_type_name_c) && typeid(*right_type) == typeid(date_type_name_c)) || - (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) || - (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(tod_type_name_c)) || - (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) || - (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(dt_type_name_c))) - return print_binary_function("__time_sub", symbol->l_exp, symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type)) - return print_binary_expression(symbol->l_exp, symbol->r_exp, " - "); - ERROR; - return NULL; -} - -void *visit(mul_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if ((typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_integer_type(right_type)) || - (typeid(*left_type) == typeid(time_type_name_c) && search_expression_type->is_real_type(right_type))) - return print_binary_function("__time_mul", symbol->l_exp, symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type)) - return print_binary_expression(symbol->l_exp, symbol->r_exp, " * "); - ERROR; - return NULL; -} - -void *visit(div_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type)) - return print_binary_expression(symbol->l_exp, symbol->r_exp, " / "); - ERROR; - return NULL; -} - -void *visit(mod_expression_c *symbol) { - symbol_c *left_type = search_expression_type->get_type(symbol->l_exp); - symbol_c *right_type = search_expression_type->get_type(symbol->r_exp); - if (!search_expression_type->is_same_type(left_type, right_type)) - ERROR; - if (search_expression_type->is_integer_type(left_type) || search_expression_type->is_real_type(left_type)) { - s4o.print("(("); - symbol->r_exp->accept(*this); - s4o.print(" == 0)?0:"); - print_binary_expression(symbol->l_exp, symbol->r_exp, " % "); - s4o.print(")"); - return NULL; - } - ERROR; - return NULL; -} - -/* TODO: power expression... */ -void *visit(power_expression_c *symbol) {ERROR; return print_binary_expression(symbol->l_exp, symbol->r_exp, " ** ");} -void *visit(neg_expression_c *symbol) {return print_unary_expression(symbol->exp, " -");} - -void *visit(not_expression_c *symbol) { - symbol_c *exp_type = search_expression_type->get_type(symbol->exp); - if (!search_expression_type->is_binary_type(exp_type)) - ERROR; - return print_unary_expression(symbol->exp, search_expression_type->is_bool_type(exp_type)?"!":"~"); -} - -void *visit(function_invocation_c *symbol) { - function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name); - - if (f_decl == function_symtable.end_value()) { - /* The function called is not in the symtable, so we test if it is a - * standard function defined in standard */ - - function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name); - if (current_function_type == function_none) ERROR; - - symbol_c *function_return_type = search_expression_type->get_type(symbol); - - function_call_param_iterator_c function_call_param_iterator(symbol); - - int nb_param = ((list_c *)symbol->parameter_assignment_list)->n; - -#include "st_code_gen.c" - -#if 0 - for(int current_param = 0; current_param < nb_param; current_param++) { - symbol_c *param_name = NULL; - switch (current_function_type) { - case function_add: - case function_and: - case function_or: - param_name = generate_param_name("IN%d", current_param + 1); - break; - case function_sub: - if (current_param < 2) - param_name = generate_param_name("IN%d", current_param + 1); - else - ERROR; - break; - default: ERROR; - } - - /* Get the value from a foo( = ) style call */ - symbol_c *param_value = function_call_param_iterator.search(param_name); - delete param_name; - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - - if (param_value == NULL) ERROR; - - switch (current_function_type) { - case function_add: - if (search_expression_type->is_time_type(function_return_type)) { - if (current_param == 0) { - s4o.print("__time_add("); - param_value->accept(*this); - } - else if (current_param == 1) { - s4o.print(", "); - param_value->accept(*this); - s4o.print(")"); - } - else ERROR; - } - else { - if (current_param == 0) - s4o.print("("); - else - s4o.print(" + "); - param_value->accept(*this); - if (current_param == nb_param - 1) - s4o.print(")"); - } - break; - case function_sub: - if (search_expression_type->is_time_type(function_return_type)) { - if (current_param == 0) { - s4o.print("__time_sub("); - param_value->accept(*this); - } - else if (current_param == 1) { - s4o.print(", "); - param_value->accept(*this); - s4o.print(")"); - } - else ERROR; - } - else { - if (current_param == 0) { - s4o.print("("); - param_value->accept(*this); - } - else if (current_param == 1) { - s4o.print(" - "); - param_value->accept(*this); - s4o.print(")"); - } - else ERROR; - } - break; - case function_and: - if (current_param == 0) - s4o.print("("); - else - if (search_expression_type->is_bool_type(function_return_type)) - s4o.print(" && "); - else - s4o.print(" & "); - param_value->accept(*this); - if (current_param == nb_param - 1) - s4o.print(")"); - break; - case function_or: - if (current_param == 0) - s4o.print("("); - else - if (search_expression_type->is_bool_type(function_return_type)) - s4o.print(" || "); - else - s4o.print(" | "); - param_value->accept(*this); - if (current_param == nb_param - 1) - s4o.print(")"); - break; - default: ERROR; - } - } /* for(...) */ -#endif - } - else { - /* loop through each function parameter, find the value we should pass - * to it, and then output the c equivalent... - */ - function_param_iterator_c fp_iterator(f_decl); - - symbol->function_name->accept(*this); - s4o.print("("); - s4o.indent_right(); - - identifier_c *param_name; - function_call_param_iterator_c function_call_param_iterator(symbol); - for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { - if (i != 1) - s4o.print(",\n"+s4o.indent_spaces); - - function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); - - /* Get the value from a foo( = ) style call */ - symbol_c *param_value = function_call_param_iterator.search(param_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - - symbol_c *param_type = fp_iterator.param_type(); - if (param_type == NULL) ERROR; - - switch (param_direction) { - case function_param_iterator_c::direction_in: - if (param_value == NULL) { - /* No value given for parameter, so we must use the default... */ - /* First check whether default value specified in function declaration...*/ - param_value = fp_iterator.default_value(); - } - if (param_value == NULL) { - /* If not, get the default value of this variable's type */ - param_value = (symbol_c *)param_type->accept(*type_initial_value_c::instance()); - } - if (param_value == NULL) ERROR; - param_value->accept(*this); - break; - case function_param_iterator_c::direction_out: - case function_param_iterator_c::direction_inout: - if (param_value == NULL) { - /* no parameter value given, so we pass a previously declared temporary variable. */ - std::string *temp_var_name = temp_var_name_factory.new_name(); - s4o.print(*temp_var_name); - delete temp_var_name; - } else { - param_value->accept(*this); - } - break; - case function_param_iterator_c::direction_extref: - /* TODO! */ - ERROR; - break; - } /* switch */ - } /* for(...) */ - // symbol->parameter_assignment->accept(*this); - s4o.print(")"); - s4o.indent_left(); - } - - return NULL; -} - -/********************/ -/* B 3.2 Statements */ -/********************/ -void *visit(statement_list_c *symbol) { - return print_list(symbol, s4o.indent_spaces, ";\n" + s4o.indent_spaces, ";\n"); -} - -/*********************************/ -/* B 3.2.1 Assignment Statements */ -/*********************************/ -void *visit(assignment_statement_c *symbol) { - symbol->l_exp->accept(*this); - s4o.print(" = "); - symbol->r_exp->accept(*this); - return NULL; -} - -/*****************************************/ -/* B 3.2.2 Subprogram Control Statements */ -/*****************************************/ - -/* fb_name '(' [param_assignment_list] ')' */ -/* param_assignment_list -> may be NULL ! */ -//SYM_REF2(fb_invocation_c, fb_name, param_assignment_list) -void *visit(fb_invocation_c *symbol) { - TRACE("fb_invocation_c"); - /* first figure out what is the name of the function block type of the function block being called... */ - symbol_c *function_block_type_name = this->search_fb_instance_decl->get_type_name(symbol->fb_name); - /* should never occur. The function block instance MUST have been declared... */ - if (function_block_type_name == NULL) ERROR; - - /* Now find the declaration of the function block type being called... */ - function_block_declaration_c *fb_decl = function_block_type_symtable.find_value(function_block_type_name); - /* should never occur. The function block type being called MUST be in the symtable... */ - if (fb_decl == function_block_type_symtable.end_value()) ERROR; - - /* loop through each function block parameter, find the value we should pass - * to it, and then output the c equivalent... - */ - function_param_iterator_c fp_iterator(fb_decl); - identifier_c *param_name; - function_call_param_iterator_c function_call_param_iterator(symbol); - for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { - function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); - - /* Get the value from a foo( = ) style call */ - symbol_c *param_value = function_call_param_iterator.search(param_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - - /* now output the value assignment */ - if (param_value != NULL) - if ((param_direction == function_param_iterator_c::direction_in) || - (param_direction == function_param_iterator_c::direction_inout)) { - print_variable_prefix(); - symbol->fb_name->accept(*this); - s4o.print("."); - param_name->accept(*this); - s4o.print(" = "); - param_value->accept(*this); - s4o.print(";\n" + s4o.indent_spaces); - } - } /* for(...) */ - - /* now call the function... */ - function_block_type_name->accept(*this); - s4o.print(FB_FUNCTION_SUFFIX); - s4o.print("(&"); - print_variable_prefix(); - symbol->fb_name->accept(*this); - s4o.print(")"); - - /* loop through each function parameter, find the variable to which - * we should atribute the value of all output or inoutput parameters. - */ - fp_iterator.reset(); - function_call_param_iterator.reset(); - for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { - function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); - - /* Get the value from a foo( = ) style call */ - symbol_c *param_value = function_call_param_iterator.search(param_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - - /* now output the value assignment */ - if (param_value != NULL) - if ((param_direction == function_param_iterator_c::direction_out) || - (param_direction == function_param_iterator_c::direction_inout)) { - s4o.print(";\n"+ s4o.indent_spaces); - param_value->accept(*this); - s4o.print(" = "); - print_variable_prefix(); - symbol->fb_name->accept(*this); - s4o.print("."); - param_name->accept(*this); - } - } /* for(...) */ - - return NULL; -} - - - - -/* helper symbol for fb_invocation */ -/* param_assignment_list ',' param_assignment */ -void *visit(param_assignment_list_c *symbol) { - TRACE("param_assignment_list_c"); - /* this should never be called... */ - ERROR; - return NULL; -// return print_list(symbol, "", ", "); -} - - -void *visit(input_variable_param_assignment_c *symbol) { - TRACE("input_variable_param_assignment_c"); - /* this should never be called... */ - ERROR; - return NULL; -/* - symbol->variable_name->accept(*this); - s4o.print(" = "); - symbol->expression->accept(*this); - return NULL; -*/ -} - -void *visit(output_variable_param_assignment_c *symbol) { - TRACE("output_variable_param_assignment_c"); - /* this should never be called... */ - ERROR; - return NULL; -/* - s4o.print(s4o.indent_spaces); - if (symbol->not_param != NULL) - symbol->not_param->accept(*this); - symbol->variable_name->accept(*this); - s4o.print(" => "); - symbol->variable->accept(*this); - return NULL; -*/ -} - -// TODO: the NOT symbol in function (block) calls... -void *visit(not_paramassign_c *symbol) { - TRACE("not_paramassign_c"); - /* this should never be called... */ - ERROR; - return NULL; -/* - s4o.print("NOT "); - return NULL; -*/ -} - - -/********************************/ -/* B 3.2.3 Selection Statements */ -/********************************/ -void *visit(if_statement_c *symbol) { - s4o.print("if ("); - symbol->expression->accept(*this); - s4o.print(") {\n"); - s4o.indent_right(); - symbol->statement_list->accept(*this); - s4o.indent_left(); - symbol->elseif_statement_list->accept(*this); - - if (symbol->else_statement_list != NULL) { - s4o.print(s4o.indent_spaces); s4o.print("} else {\n"); - s4o.indent_right(); - symbol->else_statement_list->accept(*this); - s4o.indent_left(); - } - s4o.print(s4o.indent_spaces); s4o.print("}"); - return NULL; -} - -/* helper symbol for if_statement */ -void *visit(elseif_statement_list_c *symbol) {return print_list(symbol);} - -/* helper symbol for elseif_statement_list */ -void *visit(elseif_statement_c *symbol) { - s4o.print(s4o.indent_spaces); s4o.print("} else if ("); - symbol->expression->accept(*this); - s4o.print(") {\n"); - s4o.indent_right(); - symbol->statement_list->accept(*this); - s4o.indent_left(); - return NULL; -} - -void *visit(case_statement_c *symbol) { - s4o.print("switch("); - symbol->expression->accept(*this); - s4o.print(") {\n"); - s4o.indent_right(); - symbol->case_element_list->accept(*this); - if (symbol->statement_list != NULL) { - s4o.print(s4o.indent_spaces + "default:\n"); - s4o.indent_right(); - symbol->statement_list->accept(*this); - s4o.print(s4o.indent_spaces + "break;\n"); - s4o.indent_left(); - } - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "}"); - return NULL; -} - -/* helper symbol for case_statement */ -void *visit(case_element_list_c *symbol) {return print_list(symbol);} - -void *visit(case_element_c *symbol) { - s4o.print(s4o.indent_spaces + "case "); - symbol->case_list->accept(*this); - s4o.print(" :\n"); - s4o.indent_right(); - symbol->statement_list->accept(*this); - s4o.print(s4o.indent_spaces + "break;\n"); - s4o.indent_left(); - return NULL; -} - -void *visit(case_list_c *symbol) {return print_list(symbol, "", ", ");} - -/********************************/ -/* B 3.2.4 Iteration Statements */ -/********************************/ -void *visit(for_statement_c *symbol) { - s4o.print("for("); - symbol->control_variable->accept(*this); - s4o.print(" = "); - symbol->beg_expression->accept(*this); - s4o.print("; "); - symbol->control_variable->accept(*this); - s4o.print(" != "); - symbol->end_expression->accept(*this); - s4o.print("; "); - symbol->control_variable->accept(*this); - if (symbol->by_expression != NULL) { - s4o.print(" += "); - symbol->by_expression->accept(*this); - } else { - s4o.print("++"); - } - s4o.print(") {\n"); - s4o.indent_right(); - symbol->statement_list->accept(*this); - s4o.indent_left(); - s4o.print(s4o.indent_spaces); s4o.print("}"); - return NULL; -} -void *visit(while_statement_c *symbol) { - s4o.print("while ("); - symbol->expression->accept(*this); - s4o.print(") {\n"); - s4o.indent_right(); - symbol->statement_list->accept(*this); - s4o.indent_left(); - s4o.print(s4o.indent_spaces); s4o.print("}"); - return NULL; -} -void *visit(repeat_statement_c *symbol) { - s4o.print("do {\n"); - s4o.indent_right(); - symbol->statement_list->accept(*this); - s4o.indent_left(); - s4o.print(s4o.indent_spaces); s4o.print("} while("); - symbol->expression->accept(*this); - s4o.print(")"); - return NULL; -} -void *visit(exit_statement_c *symbol) { - s4o.print("exit(0)"); - return NULL; -} - - - -}; /* generate_cc_st_c */ - - - - - - - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/generate_cc_tempvardecl.cc --- a/stage4/generate_cc/generate_cc_tempvardecl.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,179 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * Declare temporary variables to be later used as output parameters - * in function calls for which not all output parameters were - * defined in the original (st or il) source code. - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the IL and ST - * code. - */ - - - - -class temp_var_name_c { - private: - int counter; - - public: - void reset(void) {counter = 0;} - temp_var_name_c(void) {reset();} - - public: - std::string *new_name(void) { - std::string *new_str = new std::string(TEMP_VAR); - /* yikes!!! How to convert an int to a string elegantly??? - * Right now I (Mario) can only think of snprintf() - * C++ must have a more elegant method! - */ - int int_str_size = snprintf(NULL, 0, "%d", counter); - if (int_str_size <= 0) ERROR; - char *int_str = (char *)malloc(int_str_size+1); - if (snprintf(int_str, int_str_size+1, "%d", counter++) >= int_str_size+1) ERROR; - *new_str += int_str; - free(int_str); - return new_str; - } - -}; - - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - - - -/* Some function calls in the body of functions or function blocks - * may leave some parameters to their default values, and - * ignore some output parameters of the function being called. - * Our conversion of ST functions to C++ does not contemplate that, - * i.e. each called function must get all it's input and output - * parameters set correctly. - * For input parameters we merely need to call the function with - * the apropriate default value, but for output parameters - * we must create temporary variables to hold the output value. - * - * We declare all the temporary output variables at the begining of - * the body of each function or function block, and use them as - * in function calls later on as they become necessary... - * Note that we cannot create these variables just before a function - * call, as the function call itself may be integrated within an - * expression, or another function call! - * - * The variables are declared in the exact same order in which they - * will be used later on during the function calls, which allows us - * to simply re-create the name that was used for the temporary variable - * instead of keeping it in some list. - * The names are recreated by the temp_var_name_factory, after reset() - * has been called! - * - * This function will genertae code similar to... - * - * INT __TMP_0 = 23; - * REAL __TMP_1 = 45.5; - * ... - */ - -class generate_cc_tempvardecl_c: generate_cc_typedecl_c { - public: - generate_cc_tempvardecl_c(stage4out_c *s4o_ptr): generate_cc_typedecl_c(s4o_ptr) {} - - void generate(symbol_c *body, temp_var_name_c *temp_var_name_factory) { - temp_var_name_factory->reset(); - function_call_iterator_c fcall_iterator(body); - for(symbol_c *finvocation = NULL; (finvocation = fcall_iterator.next()) != NULL;) { - /* get the name of the next function that gets called */ - identifier_c *fcalled_name = fcall_iterator.fname(); - /* get that function's declaration... */ - function_declaration_c *fdecl = function_symtable.find_value(fcalled_name); - if (fdecl == function_symtable.end_value()) { - function_type_t function_type = get_function_type(fcalled_name); - if (function_type == function_none) ERROR; - return; - } - /* create iterator to iterate through each of the called function's parameters... */ - function_param_iterator_c fp_iterator(fdecl); - - /* iterate through each of the called function's parameters... */ - identifier_c *param_name = NULL; - function_call_param_iterator_c function_call_param_iterator(finvocation); - for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { - - function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); - if (param_direction == function_param_iterator_c::direction_in) - /* ignore input only parameters... - * we do not need to create temporary variables for these! - */ - continue; - - /* Get the value from a foo( = ) style call */ - symbol_c *param_value = function_call_param_iterator.search(param_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - - if (param_value != NULL) - /* ignore output parameters to which a variable is passed... - * we do not need to create temporary variables for these! - */ - continue; - - symbol_c *param_type = fp_iterator.param_type(); - - /* get the parameter's default value */ - param_value = fp_iterator.default_value(); - - /* If no default value specified in function declaration, - * get the default value of this variable's type - */ - if (param_value == NULL) - param_value = (symbol_c *)param_type->accept(*type_initial_value_c::instance()); - if (param_value == NULL) ERROR; - - /* now declare a temporary variable, with the correct default value... */ - s4o.print(s4o.indent_spaces); - param_type->accept(*this); - s4o.print(" "); - - std::string *temp_var_name = temp_var_name_factory->new_name(); - s4o.print(*temp_var_name); - delete temp_var_name; - - s4o.print(" = "); - param_value->accept(*this); - s4o.print(";\n"); - } - } - temp_var_name_factory->reset(); - s4o.print("\n"); - } -}; diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/generate_cc_typedecl.cc --- a/stage4/generate_cc/generate_cc_typedecl.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,467 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * Conversion of type declaration constructs. - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the IL and ST - * code. - */ - - - - - - -//#include /* required for NULL */ -//#include -//#include - -//#include "../../util/symtable.hh" - - - - - -class generate_cc_typedecl_c: public generate_cc_base_c { - - public: - generate_cc_typedecl_c(stage4out_c *s4o_ptr): generate_cc_base_c(s4o_ptr) {} - ~generate_cc_typedecl_c(void) {} - - -/***************************/ -/* B 0 - Programming Model */ -/***************************/ - /* leave for derived classes... */ - -/*************************/ -/* B.1 - Common elements */ -/*************************/ -/*******************************************/ -/* B 1.1 - Letters, digits and identifiers */ -/*******************************************/ - /* done in base class(es) */ - -/*********************/ -/* B 1.2 - Constants */ -/*********************/ - /* originally empty... */ - -/******************************/ -/* B 1.2.1 - Numeric Literals */ -/******************************/ - /* done in base class(es) */ - -/*******************************/ -/* B.1.2.2 Character Strings */ -/*******************************/ - /* done in base class(es) */ - -/***************************/ -/* B 1.2.3 - Time Literals */ -/***************************/ -/************************/ -/* B 1.2.3.1 - Duration */ -/************************/ - /* done in base class(es) */ - -/************************************/ -/* B 1.2.3.2 - Time of day and Date */ -/************************************/ - /* done in base class(es) */ - -/**********************/ -/* B.1.3 - Data types */ -/**********************/ -/***********************************/ -/* B 1.3.1 - Elementary Data Types */ -/***********************************/ - /* done in base class(es) */ - -/********************************/ -/* B.1.3.2 - Generic data types */ -/********************************/ - /* originally empty... */ - -/********************************/ -/* B 1.3.3 - Derived data types */ -/********************************/ -void *visit(subrange_spec_init_c *symbol) { - TRACE("subrange_spec_init_c"); - // TODO... - ERROR; - return NULL; -} - -void *visit(enumerated_spec_init_c *symbol) { - TRACE("enumerated_spec_init_c"); - // TODO... - ERROR; - return NULL; -} - -/* TYPE type_declaration_list END_TYPE */ -void *visit(data_type_declaration_c *symbol) { - TRACE("data_type_declaration_c"); - symbol->type_declaration_list->accept(*this); - s4o.print("\n\n"); - return NULL; -} - -/* helper symbol for data_type_declaration */ -void *visit(type_declaration_list_c *symbol) { - TRACE("type_declaration_list_c"); - return print_list(symbol); -} - -/* simple_type_name ':' simple_spec_init */ -void *visit(simple_type_declaration_c *symbol) { - TRACE("simple_type_declaration_c"); - /* add this type declaration to the type symbol table... */ - type_symtable.insert(symbol->simple_type_name, symbol->simple_spec_init); - - s4o.print("typedef "); - symbol->simple_spec_init->accept(*this); - s4o.print(" "); - symbol->simple_type_name->accept(*this); - s4o.print(";\n"); - return NULL; -} - -/* simple_specification [ASSIGN constant] */ -//SYM_REF2(simple_spec_init_c, simple_specification, constant) -// may be NULL -void *visit(simple_spec_init_c *symbol) { - TRACE("simple_spec_init_c"); - symbol->simple_specification->accept(*this); - return NULL; -} - -#if 0 -/* subrange_type_name ':' subrange_spec_init */ -SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init) - -/* subrange_specification ASSIGN signed_integer */ -SYM_REF2(subrange_spec_init_c, subrange_specification, signed_integer) - -/* integer_type_name '(' subrange')' */ -SYM_REF2(subrange_specification_c, integer_type_name, subrange) - -/* signed_integer DOTDOT signed_integer */ -SYM_REF2(subrange_c, lower_limit, upper_limit) - -/* enumerated_type_name ':' enumerated_spec_init */ -SYM_REF2(enumerated_type_declaration_c, enumerated_type_name, enumerated_spec_init) - -/* enumerated_specification ASSIGN enumerated_value */ -SYM_REF2(enumerated_spec_init_c, enumerated_specification, enumerated_value) - -/* helper symbol for enumerated_specification->enumerated_spec_init */ -/* enumerated_value_list ',' enumerated_value */ -SYM_LIST(enumerated_value_list_c) - -/* enumerated_type_name '#' identifier */ -SYM_REF2(enumerated_value_c, type, value) - -/* identifier ':' array_spec_init */ -SYM_REF2(array_type_declaration_c, identifier, array_spec_init) - -/* array_specification [ASSIGN array_initialization} */ -/* array_initialization may be NULL ! */ -SYM_REF2(array_spec_init_c, array_specification, array_initialization) - -/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */ -SYM_REF2(array_specification_c, array_subrange_list, non_generic_type_name) - -/* helper symbol for array_specification */ -/* array_subrange_list ',' subrange */ -SYM_LIST(array_subrange_list_c) - -/* array_initialization: '[' array_initial_elements_list ']' */ -/* helper symbol for array_initialization */ -/* array_initial_elements_list ',' array_initial_elements */ -SYM_LIST(array_initial_elements_list_c) - -/* integer '(' [array_initial_element] ')' */ -/* array_initial_element may be NULL ! */ -SYM_REF2(array_initial_elements_c, integer, array_initial_element) -#endif - -/* structure_type_name ':' structure_specification */ -//SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification) -void *visit(structure_type_declaration_c *symbol) { - TRACE("structure_type_declaration_c"); - /* add this type declaration to the type symbol table... */ - type_symtable.insert(symbol->structure_type_name, symbol->structure_specification); - - s4o.print("typedef "); - symbol->structure_specification->accept(*this); - s4o.print(" "); - symbol->structure_type_name->accept(*this); - s4o.print(";\n"); - return NULL; -} - -/* structure_type_name ASSIGN structure_initialization */ -/* structure_initialization may be NULL ! */ -//SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization) -void *visit(initialized_structure_c *symbol) { - TRACE("initialized_structure_c"); - symbol->structure_type_name->accept(*this); - return NULL; -} - -/* helper symbol for structure_declaration */ -/* structure_declaration: STRUCT structure_element_declaration_list END_STRUCT */ -/* structure_element_declaration_list structure_element_declaration ';' */ -//SYM_LIST(structure_element_declaration_list_c) -void *visit(structure_element_declaration_list_c *symbol) { - TRACE("structure_element_declaration_list_c"); - s4o.print("struct {\n"); - s4o.indent_right(); - s4o.print(s4o.indent_spaces); - - print_list(symbol); - - s4o.indent_left(); - s4o.print(s4o.indent_spaces); - s4o.print("}"); - return NULL; -} - -/* structure_element_name ':' spec_init */ -//SYM_REF2(structure_element_declaration_c, structure_element_name, spec_init) -void *visit(structure_element_declaration_c *symbol) { - TRACE("structure_element_declaration_c"); - - symbol->spec_init->accept(*this); - s4o.print(" "); - symbol->structure_element_name->accept(*this); - s4o.print(";\n"); - s4o.print(s4o.indent_spaces); - - return NULL; -} - -/* helper symbol for structure_initialization */ -/* structure_initialization: '(' structure_element_initialization_list ')' */ -/* structure_element_initialization_list ',' structure_element_initialization */ -//SYM_LIST(structure_element_initialization_list_c) -void *visit(structure_element_initialization_list_c *symbol) { - TRACE("structure_element_initialization_list_c"); - - // TODO ??? - ERROR; - return NULL; -} - -/* structure_element_name ASSIGN value */ -//SYM_REF2(structure_element_initialization_c, structure_element_name, value) -void *visit(structure_element_initialization_c *symbol) { - TRACE("structure_element_initialization_c"); - - // TODO ??? - ERROR; - return NULL; -} - -#if 0 -/* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ -/* - * NOTE: - * (Summary: Contrary to what is expected, the - * string_type_declaration_c is not used to store - * simple string type declarations that do not include - * size limits. - * For e.g.: - * str1_type: STRING := "hello!" - * will be stored in a simple_type_declaration_c - * instead of a string_type_declaration_c. - * The following: - * str2_type: STRING [64] := "hello!" - * will be stored in a sring_type_declaration_c - * - * Read on for why this is done... - * End Summary) - * - * According to the spec, the valid construct - * TYPE new_str_type : STRING := "hello!"; END_TYPE - * has two possible routes to type_declaration... - * - * Route 1: - * type_declaration: single_element_type_declaration - * single_element_type_declaration: simple_type_declaration - * simple_type_declaration: identifier ':' simple_spec_init - * simple_spec_init: simple_specification ASSIGN constant - * (shift: identifier <- 'new_str_type') - * simple_specification: elementary_type_name - * elementary_type_name: STRING - * (shift: elementary_type_name <- STRING) - * (reduce: simple_specification <- elementary_type_name) - * (shift: constant <- "hello!") - * (reduce: simple_spec_init: simple_specification ASSIGN constant) - * (reduce: ...) - * - * - * Route 2: - * type_declaration: string_type_declaration - * string_type_declaration: identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init - * (shift: identifier <- 'new_str_type') - * elementary_string_type_name: STRING - * (shift: elementary_string_type_name <- STRING) - * (shift: string_type_declaration_size <- empty ) - * string_type_declaration_init: ASSIGN character_string - * (shift: character_string <- "hello!") - * (reduce: string_type_declaration_init <- ASSIGN character_string) - * (reduce: string_type_declaration <- identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init ) - * (reduce: type_declaration <- string_type_declaration) - * - * - * At first glance it seems that removing route 1 would make - * the most sense. Unfortunately the construct 'simple_spec_init' - * shows up multiple times in other rules, so changing this construct - * would also mean changing all the rules in which it appears. - * I (Mario) therefore chose to remove route 2 instead. This means - * that the above declaration gets stored in a - * simple_type_declaration_c, and not in a string_type_declaration_c - * as would be expected! - */ -/* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ -SYM_REF4(string_type_declaration_c, string_type_name, - elementary_string_type_name, - string_type_declaration_size, - string_type_declaration_init) /* may be == NULL! */ -#endif - -/*********************/ -/* B 1.4 - Variables */ -/*********************/ - /* done in base class(es) */ - -/********************************************/ -/* B.1.4.1 Directly Represented Variables */ -/********************************************/ -// direct_variable: direct_variable_token {$$ = new direct_variable_c($1);}; -void *visit(direct_variable_c *symbol) { - TRACE("direct_variable_c"); - /* Do not use print_token() as it will change everything into uppercase */ - if (strlen(symbol->value) == 0) ERROR; - return s4o.printlocation(symbol->value + 1); -} - - -/*************************************/ -/* B.1.4.2 Multi-element Variables */ -/*************************************/ - /* done in base class(es) */ - -/******************************************/ -/* B 1.4.3 - Declaration & Initialisation */ -/******************************************/ - /* leave for derived classes... */ - -/**************************************/ -/* B.1.5 - Program organization units */ -/**************************************/ -/***********************/ -/* B 1.5.1 - Functions */ -/***********************/ - /* leave for derived classes... */ - -/*****************************/ -/* B 1.5.2 - Function Blocks */ -/*****************************/ - /* leave for derived classes... */ - -/**********************/ -/* B 1.5.3 - Programs */ -/**********************/ - /* leave for derived classes... */ - -/*********************************************/ -/* B.1.6 Sequential function chart elements */ -/*********************************************/ - -/********************************/ -/* B 1.7 Configuration elements */ -/********************************/ - /* leave for derived classes... */ - -/****************************************/ -/* B.2 - Language IL (Instruction List) */ -/****************************************/ -/***********************************/ -/* B 2.1 Instructions and Operands */ -/***********************************/ - /* leave for derived classes... */ - -/*******************/ -/* B 2.2 Operators */ -/*******************/ - /* leave for derived classes... */ - - -/***************************************/ -/* B.3 - Language ST (Structured Text) */ -/***************************************/ -/***********************/ -/* B 3.1 - Expressions */ -/***********************/ - /* leave for derived classes... */ - -/********************/ -/* B 3.2 Statements */ -/********************/ - /* leave for derived classes... */ - -/*********************************/ -/* B 3.2.1 Assignment Statements */ -/*********************************/ - /* leave for derived classes... */ - -/*****************************************/ -/* B 3.2.2 Subprogram Control Statements */ -/*****************************************/ - /* leave for derived classes... */ - -/********************************/ -/* B 3.2.3 Selection Statements */ -/********************************/ - /* leave for derived classes... */ - -/********************************/ -/* B 3.2.4 Iteration Statements */ -/********************************/ - /* leave for derived classes... */ - - - - -}; /* generate_cc_typedecl_c */ - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/generate_cc_vardecl.cc --- a/stage4/generate_cc/generate_cc_vardecl.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1702 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * Conversion of variable declaration constructs. - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the IL and ST - * code. - */ - - - - -//#include /* required for NULL */ -//#include -//#include - -//#include "../../util/symtable.hh" - - - - - - - - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - - - - -class generate_cc_vardecl_c: protected generate_cc_typedecl_c { - - /* A Helper class to the main class... */ - /* print a string, except the first time it is called */ - /* used to print the separator "," before each variable - * declaration, except the first... - * - * Needs to be done in a seperate class because this is called - * from within various locations within the code. - */ - class next_var_c { - private: - bool print_flag; - std::string str1, str2; - - next_var_c *embedded_scope; - - public: - next_var_c(std::string s1, std::string s2) { - str1 = s1; - str2 = s2; - print_flag = false; - embedded_scope = NULL; - } - - std::string get(void) { - if (NULL != embedded_scope) - return embedded_scope->get(); - - bool old_print_flag = print_flag; - print_flag = true; - if (!old_print_flag) - return str1; - else - return str2; - } - - /* Create a new next_var_c for an embedded scope. - * From now on, every call to get() will return the - * inner-most scope...! - */ - void push(std::string s1, std::string s2) { - if (NULL != embedded_scope) - return embedded_scope->push(s1, s2); - - embedded_scope = new next_var_c(s1, s2); - if (NULL == embedded_scope) - ERROR; - return; - } - - /* Remove the inner-most scope... */ - void pop(void) { - if (NULL != embedded_scope) - return embedded_scope->pop(); - - delete embedded_scope; - embedded_scope = NULL; - } - }; - - private: - /* used to generate the ',' separating the parameters in a function call */ - next_var_c *nv; - - - public: - /* the types of variables that need to be processed... */ - static const unsigned int none_vt = 0x0000; - static const unsigned int input_vt = 0x0001; // VAR_INPUT - static const unsigned int output_vt = 0x0002; // VAR_OUTPUT - static const unsigned int inoutput_vt = 0x0004; // VAR_IN_OUT - static const unsigned int private_vt = 0x0008; // VAR - static const unsigned int temp_vt = 0x0010; // VAR_TEMP - static const unsigned int external_vt = 0x0020; // VAR_EXTERNAL - static const unsigned int global_vt = 0x0040; // VAR_GLOBAL - // Globals declared inside a resource will not be declared - // unless global_vt is acompanied by resource_vt - static const unsigned int located_vt = 0x0080; // VAR AT - static const unsigned int program_vt = 0x0100; // PROGRAM (inside a configuration!) - // Programs declared inside a resource will not be declared - // unless program_vt is acompanied by resource_vt - - static const unsigned int resource_vt = 0x8000; // RESOURCE (inside a configuration!) - // This, just of itself, will not print out any declarations!! - // It must be acompanied by either program_vt and/or global_vt - - /* How variables should be declared: as local variables or - * variables within a function call interface. - * - * This will define the format of the output generated - * by this class. - * - * finterface_vf: function interface parameters - * e.g. f( int a, long b, real c ); - * --------------------- - * This class/function will produce the - * underlined code of the above examples, - * and no more!! - * - * localinit_vf: local declaration. Will include variable - * initialisation if it is not a located variable. - * e.g. - * int a = 9; - * long b = 99; - * real c = 99.9; - * - * local_vf: local declaration. Will NOT include variable - * initialisation. - * e.g. - * int a; - * long b; - * real c; - * - * init_vf: local initialisation without declaration. - * e.g. - * a = 9; - * b = 99; - * c = 99.9; - * - * constructorinit_vf: initialising of member variables... - * e.g. for a constructor... - * class_name_c(void) - * : a(9), b(99), c(99.9) { // code... } - * -------------------- - * This class/function will produce the - * underlined code of the above examples, - * and no more!! - * - * globalinit_vf: initialising of static c++ variables. These - * variables may have been declared as static inside - * a class, in which case the scope within which they were - * previously delcared must be passed as the second parameter - * to the print() function. - * - * e.g. - * __plc_pt_c START_P::loc = __plc_pt_c("I2"); - */ - typedef enum {finterface_vf, - local_vf, - localstatic_vf, - localinit_vf, - init_vf, - constructorinit_vf, - globalinit_vf - } varformat_t; - - - private: - /* variable used to store the types of variables that need to be processed... */ - /* Only set in the constructor...! */ - /* Will contain a set of values of generate_cc_vardecl_c::XXXX_vt */ - unsigned int wanted_vartype; - /* variable used to store the type of variable currently being processed... */ - /* Will contain a single value of generate_cc_vardecl_c::XXXX_vt */ - unsigned int current_vartype; - - /* How variables should be declared: as local variables or - * variables within a function interface... - */ - /* Only set in the constructor...! */ - varformat_t wanted_varformat; - - /* The number of variables already declared. */ - /* Used to declare 'void' in case no variables are declared in a function interface... */ - int finterface_var_count; - - - - /* Holds the references to the type and initial value - * of the variables currently being declared. - * Please read the comment under var1_init_decl_c for further - * details... - * - * We make an effort to keep these pointers pointing to NULL - * whenever we are outside the scope of variable declaration - * (i.e. when we are traversing a part of the parse tree which - * is not part of variable declaration) in order tio try to catch - * any bugs as soon as possible. - */ - symbol_c *current_var_type_symbol; - symbol_c *current_var_init_symbol; - void update_type_init(symbol_c *symbol /* a spec_init_c, subrange_spec_init_c, etc... */ ) { - this->current_var_type_symbol = spec_init_sperator_c::get_spec(symbol); - this->current_var_init_symbol = spec_init_sperator_c::get_init(symbol); - if (NULL == this->current_var_type_symbol) - ERROR; - if (NULL == this->current_var_init_symbol) { - /* We try to find the data type's default value... */ - this->current_var_init_symbol = (symbol_c *)this->current_var_type_symbol->accept(*type_initial_value_c::instance()); - /* Note that Function Block 'data types' do not have a default value, so we cannot abort if no default value is found! */ - /* - if (NULL == this->current_var_init_symbol) - ERROR; - */ - } - } - - void void_type_init(void) { - this->current_var_type_symbol = NULL; - this->current_var_init_symbol = NULL; - } - - /* Only used when wanted_varformat == globalinit_vf - * Holds a pointer to an identifier_c, which in turns contains - * the identifier of the scope within which the static member was - * declared. - */ - symbol_c *globalnamespace; - - /* Actually produce the output where variables are declared... */ - /* Note that located variables are the exception, they - * being declared in the located_var_decl_c visitor... - */ - void *declare_variables(symbol_c *symbol, bool is_fb = false) { - list_c *list = dynamic_cast(symbol); - /* should NEVER EVER occur!! */ - if (list == NULL) ERROR; - - /* now to produce the c equivalent... */ - if ((wanted_varformat == local_vf) || - (wanted_varformat == init_vf) || - (wanted_varformat == localinit_vf)) { - for(int i = 0; i < list->n; i++) { - s4o.print(s4o.indent_spaces); - if (wanted_varformat != init_vf) { - this->current_var_type_symbol->accept(*this); - s4o.print(" "); - } - print_variable_prefix(); - list->elements[i]->accept(*this); - if (wanted_varformat != local_vf) { - if (this->current_var_init_symbol != NULL) { - s4o.print(" = "); - this->current_var_init_symbol->accept(*this); - } - } - s4o.print(";\n"); - } - } - - if (wanted_varformat == finterface_vf) { - for(int i = 0; i < list->n; i++) { - finterface_var_count++; - s4o.print(nv->get()); - s4o.print("\n" + s4o.indent_spaces); - this->current_var_type_symbol->accept(*this); - if ((current_vartype & (output_vt | inoutput_vt)) != 0) - s4o.print(" &"); - else - s4o.print(" "); - list->elements[i]->accept(*this); - /* We do not print the initial value at function declaration! - * It is up to the caller to pass the correct default value - * if none is specified in the ST source code - */ - /* if (this->current_var_init_symbol != NULL) { - s4o.print(" = "); this->current_var_init_symbol->accept(*this);} - */ - } - } - - if (wanted_varformat == constructorinit_vf) { - for(int i = 0; i < list->n; i++) { - if (is_fb) { - s4o.print(nv->get()); - this->current_var_type_symbol->accept(*this); - s4o.print(FB_INIT_SUFFIX); - s4o.print("(&"); - this->print_variable_prefix(); - list->elements[i]->accept(*this); - s4o.print(");"); - } - else if (this->current_var_init_symbol != NULL) { - s4o.print(nv->get()); - this->print_variable_prefix(); - list->elements[i]->accept(*this); - s4o.print(" = "); - this->current_var_init_symbol->accept(*this); - s4o.print(";"); - } - } - } - - return NULL; - } - - - - - public: - generate_cc_vardecl_c(stage4out_c *s4o_ptr, varformat_t varformat, unsigned int vartype) - : generate_cc_typedecl_c(s4o_ptr) { - wanted_varformat = varformat; - wanted_vartype = vartype; - current_vartype = none_vt; - current_var_type_symbol = NULL; - current_var_init_symbol = NULL; - globalnamespace = NULL; - nv = NULL; - } - - ~generate_cc_vardecl_c(void) {} - - - void print(symbol_c *symbol, symbol_c *scope = NULL, const char *variable_prefix = NULL) { - this->set_variable_prefix(variable_prefix); - if (globalinit_vf == wanted_varformat) - globalnamespace = scope; - - finterface_var_count = 0; - - switch (wanted_varformat) { - case constructorinit_vf: nv = new next_var_c("", "\n"+s4o.indent_spaces); break; - case finterface_vf: /* fall through... */ - case localinit_vf: /* fall through... */ - case local_vf: nv = new next_var_c("", ", "); break; - default: nv = NULL; - } /* switch() */ - - symbol->accept(*this); - - /* special case... */ - if (wanted_varformat == finterface_vf) - if (finterface_var_count == 0) - s4o.print("void"); - - delete nv; - nv = NULL; - globalnamespace = NULL; - } - - - protected: -/***************************/ -/* B 0 - Programming Model */ -/***************************/ - /* leave for derived classes... */ - -/*************************/ -/* B.1 - Common elements */ -/*************************/ -/*******************************************/ -/* B 1.1 - Letters, digits and identifiers */ -/*******************************************/ - /* done in base class(es) */ - -/*********************/ -/* B 1.2 - Constants */ -/*********************/ - /* originally empty... */ - -/******************************/ -/* B 1.2.1 - Numeric Literals */ -/******************************/ - /* done in base class(es) */ - -/*******************************/ -/* B.1.2.2 Character Strings */ -/*******************************/ - /* done in base class(es) */ - -/***************************/ -/* B 1.2.3 - Time Literals */ -/***************************/ -/************************/ -/* B 1.2.3.1 - Duration */ -/************************/ - /* done in base class(es) */ - -/************************************/ -/* B 1.2.3.2 - Time of day and Date */ -/************************************/ - /* done in base class(es) */ - -/**********************/ -/* B.1.3 - Data types */ -/**********************/ -/***********************************/ -/* B 1.3.1 - Elementary Data Types */ -/***********************************/ - /* done in base class(es) */ - -/********************************/ -/* B.1.3.2 - Generic data types */ -/********************************/ - /* originally empty... */ - -/********************************/ -/* B 1.3.3 - Derived data types */ -/********************************/ - /* done in base class(es) */ - -/*********************/ -/* B 1.4 - Variables */ -/*********************/ - /* done in base class(es) */ - -/********************************************/ -/* B.1.4.1 Directly Represented Variables */ -/********************************************/ - /* done in base class(es) */ - -/*************************************/ -/* B.1.4.2 Multi-element Variables */ -/*************************************/ - /* done in base class(es) */ - -/******************************************/ -/* B 1.4.3 - Declaration & Initialisation */ -/******************************************/ -void *visit(constant_option_c *symbol) {s4o.print("CONSTANT"); return NULL;} -void *visit(retain_option_c *symbol) {s4o.print("RETAIN"); return NULL;} -void *visit(non_retain_option_c *symbol) {s4o.print("NON_RETAIN"); return NULL;} - -void *visit(input_declarations_c *symbol) { - TRACE("input_declarations_c"); - if ((wanted_vartype & input_vt) != 0) { -/* - // TO DO ... - if (symbol->option != NULL) - symbol->option->accept(*this); -*/ - //s4o.indent_right(); - current_vartype = input_vt; - symbol->input_declaration_list->accept(*this); - current_vartype = none_vt; - //s4o.indent_left(); - } - return NULL; -} - -/* helper symbol for input_declarations */ -void *visit(input_declaration_list_c *symbol) { - TRACE("input_declaration_list_c"); - print_list(symbol); - return NULL; -} - -void *visit(edge_declaration_c *symbol) { - TRACE("edge_declaration_c"); - // TO DO ... - symbol->var1_list->accept(*this); - s4o.print(" : BOOL "); - symbol->edge->accept(*this); - return NULL; -} - -void *visit(raising_edge_option_c *symbol) { - // TO DO ... - s4o.print("R_EDGE"); - return NULL; -} - - -#if 0 -/* var1_list ':' array_spec_init */ -SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init) -#endif - -/* var1_list ':' initialized_structure */ -// SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure) -void *visit(structured_var_init_decl_c *symbol) { - TRACE("structured_var_init_decl_c"); - /* Please read the comments inside the var1_init_decl_c - * visitor, as they apply here too. - */ - - /* Start off by setting the current_var_type_symbol and - * current_var_init_symbol private variables... - */ - update_type_init(symbol->initialized_structure); - - /* now to produce the c equivalent... */ - symbol->var1_list->accept(*this); - - /* Values no longer in scope, and therefore no longer used. - * Make an effort to keep them set to NULL when not in use - * in order to catch bugs as soon as possible... - */ - void_type_init(); - - return NULL; -} - -/* fb_name_list ':' function_block_type_name ASSIGN structure_initialization */ -/* structure_initialization -> may be NULL ! */ -void *visit(fb_name_decl_c *symbol) { - TRACE("fb_name_decl_c"); - /* Please read the comments inside the var1_init_decl_c - * visitor, as they apply here too. - */ - - /* Start off by setting the current_var_type_symbol and - * current_var_init_symbol private variables... - */ - update_type_init(symbol); - - /* now to produce the c equivalent... */ - symbol->fb_name_list->accept(*this); - - /* Values no longer in scope, and therefore no longer used. - * Make an effort to keep them set to NULL when not in use - * in order to catch bugs as soon as possible... - */ - void_type_init(); - - return NULL; -} - -/* fb_name_list ',' fb_name */ -void *visit(fb_name_list_c *symbol) { - TRACE("fb_name_list_c"); - declare_variables(symbol, true); - return NULL; -} - - -/* VAR_OUTPUT [RETAIN | NON_RETAIN] var_init_decl_list END_VAR */ -/* option -> may be NULL ! */ -void *visit(output_declarations_c *symbol) { - TRACE("output_declarations_c"); - if ((wanted_vartype & output_vt) != 0) { -/* - // TO DO ... - if (symbol->option != NULL) - symbol->option->accept(*this); -*/ - //s4o.indent_right(); - current_vartype = output_vt; - symbol->var_init_decl_list->accept(*this); - current_vartype = none_vt; - //s4o.indent_left(); - } - return NULL; -} - -/* VAR_IN_OUT var_declaration_list END_VAR */ -void *visit(input_output_declarations_c *symbol) { - TRACE("input_output_declarations_c"); - if ((wanted_vartype & inoutput_vt) != 0) { - //s4o.indent_right(); - current_vartype = inoutput_vt; - symbol->var_declaration_list->accept(*this); - current_vartype = none_vt; - //s4o.indent_left(); - } - return NULL; -} - -/* helper symbol for input_output_declarations */ -/* var_declaration_list var_declaration ';' */ -void *visit(var_declaration_list_c *symbol) { - TRACE("var_declaration_list_c"); - print_list(symbol); - return NULL; -} - -#if 0 -/* var1_list ':' array_specification */ -SYM_REF2(array_var_declaration_c, var1_list, array_specification) -#endif - -/* var1_list ':' structure_type_name */ -//SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name) -void *visit(structured_var_declaration_c *symbol) { - TRACE("structured_var_declaration_c"); - /* Please read the comments inside the var1_init_decl_c - * visitor, as they apply here too. - */ - - /* Start off by setting the current_var_type_symbol and - * current_var_init_symbol private variables... - */ - update_type_init(symbol->structure_type_name); - - /* now to produce the c equivalent... */ - symbol->var1_list->accept(*this); - - /* Values no longer in scope, and therefore no longer used. - * Make an effort to keep them set to NULL when not in use - * in order to catch bugs as soon as possible... - */ - void_type_init(); - - return NULL; -} - - -/* VAR [CONSTANT] var_init_decl_list END_VAR */ -/* option -> may be NULL ! */ -/* helper symbol for input_declarations */ -void *visit(var_declarations_c *symbol) { - TRACE("var_declarations_c"); - if ((wanted_vartype & private_vt) != 0) { -/* - // TO DO ... - if (symbol->option != NULL) - symbol->option->accept(*this); -*/ - current_vartype = private_vt; - symbol->var_init_decl_list->accept(*this); - current_vartype = none_vt; - } - return NULL; -} - -/* VAR RETAIN var_init_decl_list END_VAR */ -void *visit(retentive_var_declarations_c *symbol) { - TRACE("retentive_var_declarations_c"); - if ((wanted_vartype & private_vt) != 0) { - current_vartype = private_vt; - symbol->var_init_decl_list->accept(*this); - current_vartype = none_vt; - } - return NULL; -} - -/* VAR [CONSTANT|RETAIN|NON_RETAIN] located_var_decl_list END_VAR */ -/* option -> may be NULL ! */ -//SYM_REF2(located_var_declarations_c, option, located_var_decl_list) -void *visit(located_var_declarations_c *symbol) { - TRACE("located_var_declarations_c"); - if ((wanted_vartype & located_vt) != 0) { -/* - // TO DO ... - if (symbol->option != NULL) - symbol->option->accept(*this); -*/ - current_vartype = located_vt; - symbol->located_var_decl_list->accept(*this); - current_vartype = none_vt; - } - return NULL; -} - -/* helper symbol for located_var_declarations */ -/* located_var_decl_list located_var_decl ';' */ -//SYM_LIST(located_var_decl_list_c) -void *visit(located_var_decl_list_c *symbol) { - TRACE("located_var_decl_list_c"); - print_list(symbol); - return NULL; -} - - -/* [variable_name] location ':' located_var_spec_init */ -/* variable_name -> may be NULL ! */ -//SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused) -void *visit(located_var_decl_c *symbol) { - TRACE("located_var_decl_c"); - /* Please read the comments inside the var1_init_decl_c - * visitor, as they apply here too. - */ - - /* Start off by setting the current_var_type_symbol and - * current_var_init_symbol private variables... - */ - update_type_init(symbol->located_var_spec_init); - - /* now to produce the c equivalent... */ - switch(wanted_varformat) { - case local_vf: - s4o.print(s4o.indent_spaces); - this->current_var_type_symbol->accept(*this); - s4o.print(" *"); - if (symbol->variable_name != NULL) - symbol->variable_name->accept(*this); - else - symbol->location->accept(*this); - s4o.print(";\n"); - break; - - case constructorinit_vf: - s4o.print(nv->get()); - s4o.print("{extern "); - this->current_var_type_symbol->accept(*this); - s4o.print(" "); - symbol->location->accept(*this); - s4o.print("; "); - print_variable_prefix(); - if (symbol->variable_name != NULL) - symbol->variable_name->accept(*this); - else - symbol->location->accept(*this); - s4o.print(" = &"); - symbol->location->accept(*this); - s4o.print(";}"); - break; - - case globalinit_vf: - s4o.print(s4o.indent_spaces + "__plc_pt_c<"); - this->current_var_type_symbol->accept(*this); - s4o.print(", 8*sizeof("); - this->current_var_type_symbol->accept(*this); - s4o.print(")> "); - if (this->globalnamespace != NULL) { - this->globalnamespace->accept(*this); - s4o.print("::"); - } - if (symbol->variable_name != NULL) - symbol->variable_name->accept(*this); - else - symbol->location->accept(*this); - - s4o.print(" = "); - - s4o.print(s4o.indent_spaces + "__plc_pt_c<"); - this->current_var_type_symbol->accept(*this); - s4o.print(", 8*sizeof("); - this->current_var_type_symbol->accept(*this); - s4o.print(")>(\""); - symbol->location->accept(*this); - s4o.print("\""); - if (this->current_var_init_symbol != NULL) { - s4o.print(", "); - this->current_var_init_symbol->accept(*this); - } - s4o.print(");\n"); - break; - - default: - ERROR; - } /* switch() */ - - /* Values no longer in scope, and therefore no longer used. - * Make an effort to keep them set to NULL when not in use - * in order to catch bugs as soon as possible... - */ - void_type_init(); - - return NULL; -} - - - - -/*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */ -/* option -> may be NULL ! */ -//SYM_REF2(external_var_declarations_c, option, external_declaration_list) -void *visit(external_var_declarations_c *symbol) { - TRACE("external_var_declarations_c"); - if ((wanted_vartype & external_vt) != 0) { -/* - // TODO ... - if (symbol->option != NULL) - symbol->option->accept(*this); -*/ - //s4o.indent_right(); - current_vartype = external_vt; - symbol->external_declaration_list->accept(*this); - current_vartype = none_vt; - //s4o.indent_left(); - } - return NULL; -} - -/* helper symbol for external_var_declarations */ -/*| external_declaration_list external_declaration';' */ -//SYM_LIST(external_declaration_list_c) -/* helper symbol for input_declarations */ -void *visit(external_declaration_list_c *symbol) { - TRACE("external_declaration_list_c"); - print_list(symbol); - return NULL; -} - - -/* global_var_name ':' (simple_specification|subrange_specification|enumerated_specification|array_specification|prev_declared_structure_type_name|function_block_type_name */ -//SYM_REF2(external_declaration_c, global_var_name, specification) -void *visit(external_declaration_c *symbol) { - TRACE("external_declaration_c"); - /* Please read the comments inside the var1_init_decl_c - * visitor, as they apply here too. - */ - - /* Start off by setting the current_var_type_symbol and - * current_var_init_symbol private variables... - */ - this->current_var_type_symbol = symbol->specification; - this->current_var_init_symbol = NULL; - - /* now to produce the c equivalent... */ - switch (wanted_varformat) { - case local_vf: - case localinit_vf: - s4o.print(s4o.indent_spaces); - this->current_var_type_symbol->accept(*this); - s4o.print(" *"); - symbol->global_var_name->accept(*this); - if ((wanted_varformat == localinit_vf) && - (this->current_var_init_symbol != NULL)) { - s4o.print(" = "); - this->current_var_init_symbol->accept(*this); - } - s4o.print(";\n"); - break; - - case constructorinit_vf: - s4o.print(nv->get()); - s4o.print("{extern "); - this->current_var_type_symbol->accept(*this); - s4o.print(" *"); - symbol->global_var_name->accept(*this); - s4o.print("; "); - print_variable_prefix(); - symbol->global_var_name->accept(*this); - s4o.print(" = "); - symbol->global_var_name->accept(*this); - s4o.print(";}"); - break; - - case finterface_vf: - finterface_var_count++; - s4o.print(nv->get()); - this->current_var_type_symbol->accept(*this); - s4o.print(" *"); - symbol->global_var_name->accept(*this); - break; - - default: - ERROR; - } - - /* Values no longer in scope, and therefore no longer used. - * Make an effort to keep them set to NULL when not in use - * in order to catch bugs as soon as possible... - */ - void_type_init(); - - return NULL; -} - - - -/*| VAR_GLOBAL [CONSTANT|RETAIN] global_var_decl_list END_VAR */ -/* option -> may be NULL ! */ -// SYM_REF2(global_var_declarations_c, option, global_var_decl_list) -void *visit(global_var_declarations_c *symbol) { - TRACE("global_var_declarations_c"); - if ((wanted_vartype & global_vt) != 0) { -/* - // TODO ... - if (symbol->option != NULL) - symbol->option->accept(*this); -*/ - //s4o.indent_right(); - unsigned int previous_vartype = current_vartype; - // previous_vartype will be either none_vt, or resource_vt - current_vartype = global_vt; - symbol->global_var_decl_list->accept(*this); - current_vartype = previous_vartype; - //s4o.indent_left(); - } - return NULL; -} - -/* helper symbol for global_var_declarations */ -/*| global_var_decl_list global_var_decl ';' */ -//SYM_LIST(global_var_decl_list_c) -void *visit(global_var_decl_list_c *symbol) { - TRACE("global_var_decl_list_c"); - print_list(symbol); - return NULL; -} - - - -/*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */ -/* type_specification ->may be NULL ! */ -// SYM_REF2(global_var_decl_c, global_var_spec, type_specification) -void *visit(global_var_decl_c *symbol) { - TRACE("global_var_decl_c"); - /* Please read the comments inside the var1_init_decl_c - * visitor, as they apply here too. - */ - - /* Start off by setting the current_var_type_symbol and - * current_var_init_symbol private variables... - */ - update_type_init(symbol->type_specification); - - /* now to produce the c equivalent... */ - symbol->global_var_spec->accept(*this); - - /* Values no longer in scope, and therefore no longer used. - * Make an effort to keep them set to NULL when not in use - * in order to catch bugs as soon as possible... - */ - void_type_init(); - - return NULL; -} - - -/*| global_var_name location */ -// SYM_REF2(global_var_spec_c, global_var_name, location) -void *visit(global_var_spec_c *symbol) { - TRACE("global_var_spec_c"); - - /* now to produce the c equivalent... */ - switch(wanted_varformat) { - case local_vf: - case localstatic_vf: - /* NOTE: located variables must be declared static, as the connection to the - * MatPLC point must be initialised at program startup, and not whenever - * a new function block is instantiated! - * Nevertheless, this construct never occurs inside a Function Block, but - * only inside a configuration. In this case, only a single instance will - * be created, directly at startup, so it is not necessary that the variables - * be declared static. - */ - s4o.print(s4o.indent_spaces); - if (symbol->global_var_name != NULL) { - s4o.print("extern "); - this->current_var_type_symbol->accept(*this); - s4o.print(" "); - symbol->location->accept(*this); - s4o.print(";\n"); - if (wanted_varformat == localstatic_vf) - s4o.print("static "); - this->current_var_type_symbol->accept(*this); - s4o.print(" *"); - symbol->global_var_name->accept(*this); - s4o.print(" = &"); - symbol->location->accept(*this); - s4o.print(";\n"); - } - break; - - case constructorinit_vf: - s4o.print(nv->get()); - - if (symbol->global_var_name != NULL) { - s4o.print("*"); - symbol->global_var_name->accept(*this); - } - else - symbol->location->accept(*this); - s4o.print(" = "); - if (this->current_var_init_symbol != NULL) { - this->current_var_init_symbol->accept(*this); - } - s4o.print(";"); - break; - - default: - ERROR; - } /* switch() */ - - return NULL; -} - - - -/* AT direct_variable */ -// SYM_REF2(location_c, direct_variable, unused) -void *visit(location_c *symbol) { - TRACE("location_c"); - return symbol->direct_variable->accept(*this); -} - - -/*| global_var_list ',' global_var_name */ -//SYM_LIST(global_var_list_c) -void *visit(global_var_list_c *symbol) { - TRACE("global_var_list_c"); - list_c *list = dynamic_cast(symbol); - /* should NEVER EVER occur!! */ - if (list == NULL) ERROR; - - /* now to produce the c equivalent... */ - switch (wanted_varformat) { - case local_vf: - case localinit_vf: - for(int i = 0; i < list->n; i++) { - s4o.print(s4o.indent_spaces); - this->current_var_type_symbol->accept(*this); - s4o.print(" __"); - list->elements[i]->accept(*this); - s4o.print(";\n"); - this->current_var_type_symbol->accept(*this); - s4o.print(" *"); - list->elements[i]->accept(*this); - s4o.print(" = &__"); - list->elements[i]->accept(*this); -#if 0 - if (wanted_varformat == localinit_vf) { - if (this->current_var_init_symbol != NULL) { - s4o.print(" = "); - this->current_var_init_symbol->accept(*this); - } - } -#endif - s4o.print(";\n"); - } - break; - - case constructorinit_vf: - if (this->current_var_init_symbol != NULL) { - for(int i = 0; i < list->n; i++) { - s4o.print(nv->get()); - - s4o.print("*"); - list->elements[i]->accept(*this); - s4o.print(" = "); - this->current_var_init_symbol->accept(*this); - s4o.print(";"); -#if 0 - /* The following code would be for globalinit_vf !! - * But it is not currently required... - */ - s4o.print(s4o.indent_spaces + "__ext_element_c<"); - this->current_var_type_symbol->accept(*this); - s4o.print("> "); - if (this->globalnamespace != NULL) { - this->globalnamespace->accept(*this); - s4o.print("::"); - } - list->elements[i]->accept(*this); - - if (this->current_var_init_symbol != NULL) { - s4o.print(" = "); - s4o.print("__ext_element_c<"); - this->current_var_type_symbol->accept(*this); - s4o.print(">("); - this->current_var_init_symbol->accept(*this); - s4o.print(")"); - } - s4o.print(";\n"); -#endif - } - } - break; - - default: - ERROR; /* not supported, and not needed either... */ - } - - return NULL; -} - - -#if 0 -/* var1_list ':' single_byte_string_spec */ -SYM_REF2(single_byte_string_var_declaration_c, var1_list, single_byte_string_spec) - -/* STRING ['[' integer ']'] [ASSIGN single_byte_character_string] */ -/* integer ->may be NULL ! */ -/* single_byte_character_string ->may be NULL ! */ -SYM_REF2(single_byte_string_spec_c, integer, single_byte_character_string) - -/* var1_list ':' double_byte_string_spec */ -SYM_REF2(double_byte_string_var_declaration_c, var1_list, double_byte_string_spec) - -/* WSTRING ['[' integer ']'] [ASSIGN double_byte_character_string] */ -/* integer ->may be NULL ! */ -/* double_byte_character_string ->may be NULL ! */ -SYM_REF2(double_byte_string_spec_c, integer, double_byte_character_string) - -/*| VAR [RETAIN|NON_RETAIN] incompl_located_var_decl_list END_VAR */ -/* option ->may be NULL ! */ -SYM_REF2(incompl_located_var_declarations_c, option, incompl_located_var_decl_list) - -/* helper symbol for incompl_located_var_declarations */ -/*| incompl_located_var_decl_list incompl_located_var_decl ';' */ -SYM_LIST(incompl_located_var_decl_list_c) - -/* variable_name incompl_location ':' var_spec */ -SYM_REF4(incompl_located_var_decl_c, variable_name, incompl_location, var_spec, unused) - -/* AT incompl_location_token */ -SYM_TOKEN(incompl_location_c) -#endif - - -void *visit(falling_edge_option_c *symbol) { - // TO DO ... - s4o.print("F_EDGE"); - return NULL; -} - - -void *visit(var1_init_decl_c *symbol) { - TRACE("var1_init_decl_c"); - /* We have several implementation alternatives here... - * - * The issue is that generation of c code - * based on the abstract syntax tree requires the reversal - * of the symbol order compared to st. For e.g.: - * (ST) a, b, c: INT := 98; - * (C ) int a=98, b=98, c=98; - * The spec_init contains the references to 'INT' and '98'. - * The var1_list contains the references to 'a', 'b', and 'c'. - * The var1_init_decl_c contains the references to spec_init and var1_list. - * - * For c code generation, the var1_init_decl_c visitor - * would need to access the internals of other classes - * (e.g. the simple_spec_init_c). - * - * We can do this using one of three methods: - * 1) Create the abstract syntax tree differently; - * 2) Access other classes from within the var1_init_decl_c; - * 3) Pass info between the visitors using global variables - * only acessible by this class (private vars) - * - * In 1), the abstract syntax tree would be built so that - * var1_init_decl_c would contain direct references to - * var1_list_c, to the var type 'INT' and to the initialiser '98' - * (as per the example above). - * - * 2) would have several sub-options to obtain the references - * to 'INT' and '98' from within var1_init_decl_c. - * In 2a), the var1_init_decl_c would use dynamic casts to determine - * the class of spec_init (simple_spec_init_c, subrange_spec_init_c or - * enumerated_spec_init_c), and from there obtain the 'INT' and '98' - * In 2b) var1_init_decl_c would have one reference for each - * simple_spec_init_c, subrange_spec_init_c and enumerated_spec_init_c, - * the apropriate one being initialised by the var1_init_decl_c constructor. - * Note that the constructor would use dynamic casts. In essence, we - * would merely be changing the location of the code with the - * dynamic casts. - * In 2c) we would use three overloaded constructors for var1_init_decl_c - * one each for simple_spec_init_c, etc... This implies - * use type specific pointers to each symbol in the bison - * parser, instead of simply using a symbol_c * for all symbols; - * - * In 3), we use two global but private variables with references to - * 'INT' and '98', that would be initiliased by the visitors to - * simple_spec_init_c, subrange_spec_init_c and enumerated_spec_init_c. - * The visitor to var1_list_c would then use the references in the global - * variables. - * - * I (Mario) have chosen to use 3). - */ - - /* Start off by setting the current_var_type_symbol and - * current_var_init_symbol private variables... - */ - update_type_init(symbol->spec_init); - - /* now to produce the c equivalent... */ - symbol->var1_list->accept(*this); - - /* Values no longer in scope, and therefore no longer used. - * Make an effort to keep them set to NULL when not in use - * in order to catch bugs as soon as possible... - */ - void_type_init(); - - return NULL; -} - - - -void *visit(var1_list_c *symbol) { - TRACE("var1_list_c"); - declare_variables(symbol); - return NULL; -} - - - - -/* intermediate helper symbol for: - * - non_retentive_var_decls - * - output_declarations - */ -void *visit(var_init_decl_list_c *symbol) { - TRACE("var_init_decl_list_c"); - return print_list(symbol); - return NULL; -} - - -/**************************************/ -/* B.1.5 - Program organization units */ -/**************************************/ -/***********************/ -/* B 1.5.1 - Functions */ -/***********************/ -/* The missing function_declaration_c - * is handled in derived classes - */ - - - -/* intermediate helper symbol for function_declaration */ -void *visit(var_declarations_list_c *symbol) { - TRACE("var_declarations_list_c"); - return print_list(symbol); -} - - -void *visit(function_var_decls_c *symbol) { - TRACE("function_var_decls_c"); - - if ((wanted_vartype & private_vt) != 0) { -/* - // TO DO ... - if (symbol->option != NULL) - symbol->option->accept(*this); -*/ - current_vartype = private_vt; - symbol->decl_list->accept(*this); - current_vartype = none_vt; - } - return NULL; -} - - -/* intermediate helper symbol for function_var_decls */ -void *visit(var2_init_decl_list_c *symbol) { - TRACE("var2_init_decl_list_c"); - print_list(symbol); - return NULL; -} - - -/*****************************/ -/* B 1.5.2 - Function Blocks */ -/*****************************/ - -/* The missing function_block_declaration_c - * is handled in derived classes - */ - - -/* VAR_TEMP temp_var_decl_list END_VAR */ -void *visit(temp_var_decls_c *symbol) { - TRACE("temp_var_decls_c"); - if ((wanted_vartype & temp_vt) != 0) { - current_vartype = temp_vt; - symbol->var_decl_list->accept(*this); - current_vartype = none_vt; - } - return NULL; -} - -/* intermediate helper symbol for temp_var_decls */ -void *visit(temp_var_decls_list_c *symbol) { - TRACE("temp_var_decls_list_c"); - return print_list(symbol); -} - -/* VAR NON_RETAIN var_init_decl_list END_VAR */ -void *visit(non_retentive_var_decls_c *symbol) { - TRACE("non_retentive_var_decls_c"); - // TODO ... guarantee the non-retain semantics! - if ((wanted_vartype & private_vt) != 0) { - current_vartype = private_vt; - symbol->var_decl_list->accept(*this); - current_vartype = none_vt; - } - return NULL; -} - - - -/**********************/ -/* B 1.5.3 - Programs */ -/**********************/ - /* leave for derived classes... */ - -/*********************************************/ -/* B.1.6 Sequential function chart elements */ -/*********************************************/ - -/********************************/ -/* B 1.7 Configuration elements */ -/********************************/ - /* Programs instantiated inside configurations are declared as variables!! */ - -/* -CONFIGURATION configuration_name - optional_global_var_declarations - (resource_declaration_list | single_resource_declaration) - optional_access_declarations - optional_instance_specific_initializations -END_CONFIGURATION -*/ -/* -SYM_REF6(configuration_declaration_c, configuration_name, global_var_declarations, resource_declarations, access_declarations, instance_specific_initializations, unused) -*/ -void *visit(configuration_declaration_c *symbol) { - TRACE("configuration_declaration_c"); - - if(symbol->global_var_declarations) - symbol->global_var_declarations->accept(*this); // will contain VAR_GLOBAL declarations!! - symbol->resource_declarations->accept(*this); // will contain PROGRAM declarations!! - return NULL; -} - - -/* helper symbol for configuration_declaration */ -// SYM_LIST(resource_declaration_list_c) -void *visit(resource_declaration_list_c *symbol) { - TRACE("resource_declaration_list_c"); - - return print_list(symbol); -} - -/* -RESOURCE resource_name ON resource_type_name - optional_global_var_declarations - single_resource_declaration -END_RESOURCE -*/ -// SYM_REF4(resource_declaration_c, resource_name, resource_type_name, global_var_declarations, resource_declaration) -void *visit(resource_declaration_c *symbol) { - TRACE("resource_declaration_c"); - - if ((wanted_vartype & resource_vt) != 0) { - s4o.print(s4o.indent_spaces + "struct {\n"); - s4o.indent_right(); - - current_vartype = resource_vt; - if (NULL != symbol->global_var_declarations) - symbol->global_var_declarations->accept(*this); // will contain VAR_GLOBAL declarations!! - if (NULL != symbol->resource_declaration) - symbol->resource_declaration->accept(*this); // will contain PROGRAM declarations!! - current_vartype = none_vt; - - s4o.indent_left(); - s4o.print(s4o.indent_spaces + "} "); - symbol->resource_name->accept(*this); - s4o.print(";\n"); - } - return NULL; -} - -/* task_configuration_list program_configuration_list */ -// SYM_REF2(single_resource_declaration_c, task_configuration_list, program_configuration_list) -void *visit(single_resource_declaration_c *symbol) { - TRACE("single_resource_declaration_c"); - - if ((wanted_vartype & program_vt) != 0) { - unsigned int previous_vartype = current_vartype; - // previous_vartype will be resource_vt - current_vartype = program_vt; - symbol->program_configuration_list->accept(*this); - current_vartype = previous_vartype; - } - return NULL; -} - - -/* helper symbol for single_resource_declaration */ -// SYM_LIST(task_configuration_list_c) - - -/* helper symbol for single_resource_declaration */ -/* | program_configuration_list program_configuration ';' */ -// SYM_LIST(program_configuration_list_c) -void *visit(program_configuration_list_c *symbol) { - TRACE("program_configuration_list_c"); - - return print_list(symbol); -} - -/* helper symbol for - * - access_path - * - instance_specific_init - */ -// SYM_LIST(any_fb_name_list_c) - -/* [resource_name '.'] global_var_name ['.' structure_element_name] */ -// SYM_REF4(global_var_reference_c, resource_name, global_var_name, structure_element_name, unused) - -/* prev_declared_program_name '.' symbolic_variable */ -// SYM_REF2(program_output_reference_c, program_name, symbolic_variable) - -/* TASK task_name task_initialization */ -// SYM_REF2(task_configuration_c, task_name, task_initialization) - -/* '(' [SINGLE ASSIGN data_source ','] [INTERVAL ASSIGN data_source ','] PRIORITY ASSIGN integer ')' */ -// SYM_REF4(task_initialization_c, single_data_source, interval_data_source, priority_data_source, unused) - -/* PROGRAM [RETAIN | NON_RETAIN] program_name [WITH task_name] ':' program_type_name ['(' prog_conf_elements ')'] */ -// SYM_REF6(program_configuration_c, retain_option, program_name, task_name, program_type_name, prog_conf_elements, unused) -private: - /* a helper function to the program_configuration_c visitor... */ - void program_constructor_call(program_configuration_c *symbol) { - program_declaration_c *p_decl = program_type_symtable.find_value(symbol->program_type_name); - - if (p_decl == program_type_symtable.end_value()) - /* should never occur. The program being called MUST be in the symtable... */ - ERROR; - - symbol->program_name->accept(*this); - s4o.print("("); - - /* loop through each function parameter, find the value we should pass - * to it, and then output the c equivalent... - */ - function_param_iterator_c fp_iterator(p_decl); - function_call_param_iterator_c function_call_param_iterator(symbol); - identifier_c *param_name; - nv->push("", ", "); - for(int i = 1; (param_name = fp_iterator.next()) != NULL; i++) { - - symbol_c *param_type = fp_iterator.param_type(); - if (param_type == NULL) ERROR; - - function_param_iterator_c::param_direction_t param_direction = fp_iterator.param_direction(); - -#if 0 - /* Get the value from a foo( = ) style call */ - symbol_c *param_value = function_call_param_iterator.search(param_name); -#endif - - switch (param_direction) { - case function_param_iterator_c::direction_in: - case function_param_iterator_c::direction_out: - case function_param_iterator_c::direction_inout: - /* ignore them all!! */ - break; - - case function_param_iterator_c::direction_extref: -#if 0 - if (param_value == NULL) - /* This is illegal in ST and IL languages. - * All variables declared in a VAR_EXTERNAL __must__ - * be initialised to reference a specific VAR_GLOBAL variable!! - * - * The semantic checker should have caught this, we check again just the - * same (especially since the semantic checker has not yet been written!). - */ - ERROR; - s4o.print(nv->get()); - s4o.print("&"); - param_value->accept(*this); -#endif - break; -#if 0 - if (param_value == NULL) { - /* no parameter value given, so we pass a previously declared temporary variable. */ - std::string *temp_var_name = temp_var_name_factory.new_name(); - s4o.print(*temp_var_name); - delete temp_var_name; - } else { - param_value->accept(*this); - } -#endif - break; - } /* switch */ - } /* for(...) */ - - // symbol->parameter_assignment->accept(*this); - s4o.print(")"); - nv->pop(); - return; -} - - -public: -void *visit(program_configuration_c *symbol) { - TRACE("program_configuration_c"); - - /* now to produce the c equivalent... */ - switch (wanted_varformat) { - case local_vf: - case localinit_vf: - s4o.print(s4o.indent_spaces); - symbol->program_type_name->accept(*this); - s4o.print(" "); - symbol->program_name->accept(*this); - if (wanted_varformat == localinit_vf) { - // TODO... - // program_call(symbol); - } - s4o.print(";\n"); - break; - - case constructorinit_vf: - s4o.print(nv->get()); - program_constructor_call(symbol); -/* - symbol->program_name->accept(*this); - s4o.print("("); - symbol->prog_conf_elements->accept(*this); - nv->pop(); - s4o.print(")"); -*/ - break; - - default: - ERROR; /* not supported, and not needed either... */ - } - - return NULL; -} - - - -/* prog_conf_elements ',' prog_conf_element */ -//SYM_LIST(prog_conf_elements_c) -void *visit(prog_conf_elements_c *symbol) { - TRACE("prog_conf_elements_c"); - - return print_list(symbol); -} - -/* fb_name WITH task_name */ -//SYM_REF2(fb_task_c, fb_name, task_name) -void *visit(fb_task_c *symbol) { - TRACE("fb_task_c"); - - /* TODO... - * - * NOTE: Not yet supported... - * We do not support allocating specific function blocks declared - * inside a program to be executed by a different task from the one - * already executing the program itself. - * This is mostly because I (Mario) simply do not understand the - * semantics the standard expects us to implement in this case. It is all - * very confusing, and very poorly defined in the standard! - */ - ERROR; - return NULL; -} - - - - - - - - - - - - - - - - - - - - - - - - - - - -/* any_symbolic_variable ASSIGN prog_data_source */ -// SYM_REF2(prog_cnxn_assign_c, symbolic_variable, prog_data_source) -void *visit(prog_cnxn_assign_c *symbol) { - TRACE("prog_cnxn_assign_c"); - - /* TODO... */ - return NULL; -} - -/* any_symbolic_variable SENDTO data_sink */ -// SYM_REF2(prog_cnxn_sendto_c, symbolic_variable, prog_data_source) -void *visit(prog_cnxn_sendto_c *symbol) { - TRACE("prog_cnxn_sendto_c"); - - /* TODO... */ - return NULL; -} - -#if 0 -/* VAR_CONFIG instance_specific_init_list END_VAR_BOGUS */ -SYM_REF2(instance_specific_initializations_c, instance_specific_init_list, unused) - -/* helper symbol for instance_specific_initializations */ -SYM_LIST(instance_specific_init_list_c) - -/* resource_name '.' program_name '.' {fb_name '.'} - ((variable_name [location] ':' located_var_spec_init) | (fb_name ':' fb_initialization)) -*/ -SYM_REF6(instance_specific_init_c, resource_name, program_name, any_fb_name_list, variable_name, location, initialization) - -/* helper symbol for instance_specific_init */ -/* function_block_type_name ':=' structure_initialization */ -SYM_REF2(fb_initialization_c, function_block_type_name, structure_initialization) - -#endif - - - - -/****************************************/ -/* B.2 - Language IL (Instruction List) */ -/****************************************/ -/***********************************/ -/* B 2.1 Instructions and Operands */ -/***********************************/ - /* leave for derived classes... */ - -/*******************/ -/* B 2.2 Operators */ -/*******************/ - /* leave for derived classes... */ - - -/***************************************/ -/* B.3 - Language ST (Structured Text) */ -/***************************************/ -/***********************/ -/* B 3.1 - Expressions */ -/***********************/ - /* leave for derived classes... */ - -/********************/ -/* B 3.2 Statements */ -/********************/ - /* leave for derived classes... */ - -/*********************************/ -/* B 3.2.1 Assignment Statements */ -/*********************************/ - /* leave for derived classes... */ - -/*****************************************/ -/* B 3.2.2 Subprogram Control Statements */ -/*****************************************/ - /* leave for derived classes... */ - -/********************************/ -/* B 3.2.3 Selection Statements */ -/********************************/ - /* leave for derived classes... */ - -/********************************/ -/* B 3.2.4 Iteration Statements */ -/********************************/ - /* leave for derived classes... */ - - - -}; /* generate_cc_vardecl_c */ - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/generate_location_list.cc --- a/stage4/generate_cc/generate_location_list.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,185 +0,0 @@ -/* - * (c) 2007 Mario de Sousa and Laurent Bessard - * - * 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) - * - */ - -/* - * This is one of the versions available for the 4th stage. - * - * This 4th stage generates a c++ source program equivalent - * to the IL and ST code. - */ - -//#include /* required for NULL */ -//#include -//#include - -//#include "../../util/symtable.hh" - - - - - - - - - -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ -/***********************************************************************/ - -class generate_location_list_c: protected iterator_visitor_c { - - protected: - stage4out_c &s4o; - - private: - symbol_c *current_var_type_symbol; - generate_cc_base_c *generate_cc_base; - search_base_type_c search_base_type; - - public: - generate_location_list_c(stage4out_c *s4o_ptr): s4o(*s4o_ptr) { - generate_cc_base = new generate_cc_base_c(s4o_ptr); - current_var_type_symbol = NULL; - } - ~generate_location_list_c(void) { - delete generate_cc_base; - } - - bool test_location_type(symbol_c *direct_variable) { - - token_c *location = dynamic_cast(direct_variable); - - if (location == NULL) - /* invalid identifiers... */ - return false; - - switch (location->value[2]) { - case 'X': // bit - if (typeid(*current_var_type_symbol) == typeid(bool_type_name_c)) return true; - break; - case 'B': // Byte, 8 bits - if (typeid(*current_var_type_symbol) == typeid(sint_type_name_c)) return true; - if (typeid(*current_var_type_symbol) == typeid(usint_type_name_c)) return true; - if (typeid(*current_var_type_symbol) == typeid(string_type_name_c)) return true; - if (typeid(*current_var_type_symbol) == typeid(byte_type_name_c)) return true; - break; - case 'W': // Word, 16 bits - if (typeid(*current_var_type_symbol) == typeid(int_type_name_c)) return true; - if (typeid(*current_var_type_symbol) == typeid(uint_type_name_c)) return true; - if (typeid(*current_var_type_symbol) == typeid(word_type_name_c)) return true; - if (typeid(*current_var_type_symbol) == typeid(wstring_type_name_c)) return true; - break; - case 'D': // Double, 32 bits - if (typeid(*current_var_type_symbol) == typeid(dint_type_name_c)) return true; - if (typeid(*current_var_type_symbol) == typeid(udint_type_name_c)) return true; - if (typeid(*current_var_type_symbol) == typeid(real_type_name_c)) return true; - if (typeid(*current_var_type_symbol) == typeid(dword_type_name_c)) return true; - break; - case 'L': // Long, 64 bits - if (typeid(*current_var_type_symbol) == typeid(lint_type_name_c)) return true; - if (typeid(*current_var_type_symbol) == typeid(ulint_type_name_c)) return true; - if (typeid(*current_var_type_symbol) == typeid(lreal_type_name_c)) return true; - if (typeid(*current_var_type_symbol) == typeid(lword_type_name_c)) return true; - break; - default: - if (typeid(*current_var_type_symbol) == typeid(bool_type_name_c)) return true; - } - return false; - } - -/********************************************/ -/* B.1.4.1 Directly Represented Variables */ -/********************************************/ - - void *visit(direct_variable_c *symbol) { - if (current_var_type_symbol) { - s4o.print("__LOCATED_VAR("); - current_var_type_symbol->accept(*generate_cc_base); - s4o.print(","); - /* Do not use print_token() as it will change everything into uppercase */ - s4o.printlocation((symbol->value)+1); - s4o.print(","); - s4o.printlocation_comasep((symbol->value)+1); - s4o.print(")\n"); - } - return NULL; - } - - -/********************************************/ -/* B.1.4.3 Declaration and initilization */ -/********************************************/ - -/* [variable_name] location ':' located_var_spec_init */ -/* variable_name -> may be NULL ! */ -//SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused) - void *visit(located_var_decl_c *symbol) { - current_var_type_symbol = spec_init_sperator_c::get_spec(symbol->located_var_spec_init); - if (current_var_type_symbol == NULL) - ERROR; - - current_var_type_symbol = (symbol_c *)(current_var_type_symbol->accept(search_base_type)); - if (current_var_type_symbol == NULL) - ERROR; - - symbol->location->accept(*this); - - current_var_type_symbol = NULL; - return NULL; - } - -/*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */ -/* type_specification ->may be NULL ! */ -//SYM_REF2(global_var_decl_c, global_var_spec, type_specification) - void *visit(global_var_decl_c *symbol) { - current_var_type_symbol = spec_init_sperator_c::get_spec(symbol->type_specification); - if (current_var_type_symbol == NULL) - ERROR; - - current_var_type_symbol = (symbol_c *)(current_var_type_symbol->accept(search_base_type)); - if (current_var_type_symbol == NULL) - ERROR; - - symbol->global_var_spec->accept(*this); - - current_var_type_symbol = NULL; - return NULL; - } - -/* AT direct_variable */ -//SYM_REF2(location_c, direct_variable, unused) - void *visit(location_c *symbol) { - if (test_location_type(symbol->direct_variable)) - symbol->direct_variable->accept(*this); - else - ERROR; - return NULL; - } - -}; /* generate_location_list_c */ diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/get_function_type_decl.c --- a/stage4/generate_cc/get_function_type_decl.c Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1297 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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 lib - * generated code, do not edit by hand - */ -function_type_t get_function_type(identifier_c *function_name) { - -if (!strcasecmp(function_name->value, "BOOL_TO_SINT")) - return function_bool_to_sint; - -if (!strcasecmp(function_name->value, "BOOL_TO_INT")) - return function_bool_to_int; - -if (!strcasecmp(function_name->value, "BOOL_TO_DINT")) - return function_bool_to_dint; - -if (!strcasecmp(function_name->value, "BOOL_TO_LINT")) - return function_bool_to_lint; - -if (!strcasecmp(function_name->value, "BOOL_TO_USINT")) - return function_bool_to_usint; - -if (!strcasecmp(function_name->value, "BOOL_TO_UINT")) - return function_bool_to_uint; - -if (!strcasecmp(function_name->value, "BOOL_TO_UDINT")) - return function_bool_to_udint; - -if (!strcasecmp(function_name->value, "BOOL_TO_ULINT")) - return function_bool_to_ulint; - -if (!strcasecmp(function_name->value, "BOOL_TO_REAL")) - return function_bool_to_real; - -if (!strcasecmp(function_name->value, "BOOL_TO_LREAL")) - return function_bool_to_lreal; - -if (!strcasecmp(function_name->value, "BOOL_TO_TIME")) - return function_bool_to_time; - -if (!strcasecmp(function_name->value, "BOOL_TO_DATE")) - return function_bool_to_date; - -if (!strcasecmp(function_name->value, "BOOL_TO_TOD")) - return function_bool_to_tod; - -if (!strcasecmp(function_name->value, "BOOL_TO_DT")) - return function_bool_to_dt; - -if (!strcasecmp(function_name->value, "BOOL_TO_STRING")) - return function_bool_to_string; - -if (!strcasecmp(function_name->value, "BOOL_TO_BYTE")) - return function_bool_to_byte; - -if (!strcasecmp(function_name->value, "BOOL_TO_WORD")) - return function_bool_to_word; - -if (!strcasecmp(function_name->value, "BOOL_TO_DWORD")) - return function_bool_to_dword; - -if (!strcasecmp(function_name->value, "BOOL_TO_LWORD")) - return function_bool_to_lword; - -if (!strcasecmp(function_name->value, "SINT_TO_BOOL")) - return function_sint_to_bool; - -if (!strcasecmp(function_name->value, "SINT_TO_INT")) - return function_sint_to_int; - -if (!strcasecmp(function_name->value, "SINT_TO_DINT")) - return function_sint_to_dint; - -if (!strcasecmp(function_name->value, "SINT_TO_LINT")) - return function_sint_to_lint; - -if (!strcasecmp(function_name->value, "SINT_TO_USINT")) - return function_sint_to_usint; - -if (!strcasecmp(function_name->value, "SINT_TO_UINT")) - return function_sint_to_uint; - -if (!strcasecmp(function_name->value, "SINT_TO_UDINT")) - return function_sint_to_udint; - -if (!strcasecmp(function_name->value, "SINT_TO_ULINT")) - return function_sint_to_ulint; - -if (!strcasecmp(function_name->value, "SINT_TO_REAL")) - return function_sint_to_real; - -if (!strcasecmp(function_name->value, "SINT_TO_LREAL")) - return function_sint_to_lreal; - -if (!strcasecmp(function_name->value, "SINT_TO_TIME")) - return function_sint_to_time; - -if (!strcasecmp(function_name->value, "SINT_TO_DATE")) - return function_sint_to_date; - -if (!strcasecmp(function_name->value, "SINT_TO_TOD")) - return function_sint_to_tod; - -if (!strcasecmp(function_name->value, "SINT_TO_DT")) - return function_sint_to_dt; - -if (!strcasecmp(function_name->value, "SINT_TO_STRING")) - return function_sint_to_string; - -if (!strcasecmp(function_name->value, "SINT_TO_BYTE")) - return function_sint_to_byte; - -if (!strcasecmp(function_name->value, "SINT_TO_WORD")) - return function_sint_to_word; - -if (!strcasecmp(function_name->value, "SINT_TO_DWORD")) - return function_sint_to_dword; - -if (!strcasecmp(function_name->value, "SINT_TO_LWORD")) - return function_sint_to_lword; - -if (!strcasecmp(function_name->value, "INT_TO_BOOL")) - return function_int_to_bool; - -if (!strcasecmp(function_name->value, "INT_TO_SINT")) - return function_int_to_sint; - -if (!strcasecmp(function_name->value, "INT_TO_DINT")) - return function_int_to_dint; - -if (!strcasecmp(function_name->value, "INT_TO_LINT")) - return function_int_to_lint; - -if (!strcasecmp(function_name->value, "INT_TO_USINT")) - return function_int_to_usint; - -if (!strcasecmp(function_name->value, "INT_TO_UINT")) - return function_int_to_uint; - -if (!strcasecmp(function_name->value, "INT_TO_UDINT")) - return function_int_to_udint; - -if (!strcasecmp(function_name->value, "INT_TO_ULINT")) - return function_int_to_ulint; - -if (!strcasecmp(function_name->value, "INT_TO_REAL")) - return function_int_to_real; - -if (!strcasecmp(function_name->value, "INT_TO_LREAL")) - return function_int_to_lreal; - -if (!strcasecmp(function_name->value, "INT_TO_TIME")) - return function_int_to_time; - -if (!strcasecmp(function_name->value, "INT_TO_DATE")) - return function_int_to_date; - -if (!strcasecmp(function_name->value, "INT_TO_TOD")) - return function_int_to_tod; - -if (!strcasecmp(function_name->value, "INT_TO_DT")) - return function_int_to_dt; - -if (!strcasecmp(function_name->value, "INT_TO_STRING")) - return function_int_to_string; - -if (!strcasecmp(function_name->value, "INT_TO_BYTE")) - return function_int_to_byte; - -if (!strcasecmp(function_name->value, "INT_TO_WORD")) - return function_int_to_word; - -if (!strcasecmp(function_name->value, "INT_TO_DWORD")) - return function_int_to_dword; - -if (!strcasecmp(function_name->value, "INT_TO_LWORD")) - return function_int_to_lword; - -if (!strcasecmp(function_name->value, "DINT_TO_BOOL")) - return function_dint_to_bool; - -if (!strcasecmp(function_name->value, "DINT_TO_SINT")) - return function_dint_to_sint; - -if (!strcasecmp(function_name->value, "DINT_TO_INT")) - return function_dint_to_int; - -if (!strcasecmp(function_name->value, "DINT_TO_LINT")) - return function_dint_to_lint; - -if (!strcasecmp(function_name->value, "DINT_TO_USINT")) - return function_dint_to_usint; - -if (!strcasecmp(function_name->value, "DINT_TO_UINT")) - return function_dint_to_uint; - -if (!strcasecmp(function_name->value, "DINT_TO_UDINT")) - return function_dint_to_udint; - -if (!strcasecmp(function_name->value, "DINT_TO_ULINT")) - return function_dint_to_ulint; - -if (!strcasecmp(function_name->value, "DINT_TO_REAL")) - return function_dint_to_real; - -if (!strcasecmp(function_name->value, "DINT_TO_LREAL")) - return function_dint_to_lreal; - -if (!strcasecmp(function_name->value, "DINT_TO_TIME")) - return function_dint_to_time; - -if (!strcasecmp(function_name->value, "DINT_TO_DATE")) - return function_dint_to_date; - -if (!strcasecmp(function_name->value, "DINT_TO_TOD")) - return function_dint_to_tod; - -if (!strcasecmp(function_name->value, "DINT_TO_DT")) - return function_dint_to_dt; - -if (!strcasecmp(function_name->value, "DINT_TO_STRING")) - return function_dint_to_string; - -if (!strcasecmp(function_name->value, "DINT_TO_BYTE")) - return function_dint_to_byte; - -if (!strcasecmp(function_name->value, "DINT_TO_WORD")) - return function_dint_to_word; - -if (!strcasecmp(function_name->value, "DINT_TO_DWORD")) - return function_dint_to_dword; - -if (!strcasecmp(function_name->value, "DINT_TO_LWORD")) - return function_dint_to_lword; - -if (!strcasecmp(function_name->value, "LINT_TO_BOOL")) - return function_lint_to_bool; - -if (!strcasecmp(function_name->value, "LINT_TO_SINT")) - return function_lint_to_sint; - -if (!strcasecmp(function_name->value, "LINT_TO_INT")) - return function_lint_to_int; - -if (!strcasecmp(function_name->value, "LINT_TO_DINT")) - return function_lint_to_dint; - -if (!strcasecmp(function_name->value, "LINT_TO_USINT")) - return function_lint_to_usint; - -if (!strcasecmp(function_name->value, "LINT_TO_UINT")) - return function_lint_to_uint; - -if (!strcasecmp(function_name->value, "LINT_TO_UDINT")) - return function_lint_to_udint; - -if (!strcasecmp(function_name->value, "LINT_TO_ULINT")) - return function_lint_to_ulint; - -if (!strcasecmp(function_name->value, "LINT_TO_REAL")) - return function_lint_to_real; - -if (!strcasecmp(function_name->value, "LINT_TO_LREAL")) - return function_lint_to_lreal; - -if (!strcasecmp(function_name->value, "LINT_TO_TIME")) - return function_lint_to_time; - -if (!strcasecmp(function_name->value, "LINT_TO_DATE")) - return function_lint_to_date; - -if (!strcasecmp(function_name->value, "LINT_TO_TOD")) - return function_lint_to_tod; - -if (!strcasecmp(function_name->value, "LINT_TO_DT")) - return function_lint_to_dt; - -if (!strcasecmp(function_name->value, "LINT_TO_STRING")) - return function_lint_to_string; - -if (!strcasecmp(function_name->value, "LINT_TO_BYTE")) - return function_lint_to_byte; - -if (!strcasecmp(function_name->value, "LINT_TO_WORD")) - return function_lint_to_word; - -if (!strcasecmp(function_name->value, "LINT_TO_DWORD")) - return function_lint_to_dword; - -if (!strcasecmp(function_name->value, "LINT_TO_LWORD")) - return function_lint_to_lword; - -if (!strcasecmp(function_name->value, "USINT_TO_BOOL")) - return function_usint_to_bool; - -if (!strcasecmp(function_name->value, "USINT_TO_SINT")) - return function_usint_to_sint; - -if (!strcasecmp(function_name->value, "USINT_TO_INT")) - return function_usint_to_int; - -if (!strcasecmp(function_name->value, "USINT_TO_DINT")) - return function_usint_to_dint; - -if (!strcasecmp(function_name->value, "USINT_TO_LINT")) - return function_usint_to_lint; - -if (!strcasecmp(function_name->value, "USINT_TO_UINT")) - return function_usint_to_uint; - -if (!strcasecmp(function_name->value, "USINT_TO_UDINT")) - return function_usint_to_udint; - -if (!strcasecmp(function_name->value, "USINT_TO_ULINT")) - return function_usint_to_ulint; - -if (!strcasecmp(function_name->value, "USINT_TO_REAL")) - return function_usint_to_real; - -if (!strcasecmp(function_name->value, "USINT_TO_LREAL")) - return function_usint_to_lreal; - -if (!strcasecmp(function_name->value, "USINT_TO_TIME")) - return function_usint_to_time; - -if (!strcasecmp(function_name->value, "USINT_TO_DATE")) - return function_usint_to_date; - -if (!strcasecmp(function_name->value, "USINT_TO_TOD")) - return function_usint_to_tod; - -if (!strcasecmp(function_name->value, "USINT_TO_DT")) - return function_usint_to_dt; - -if (!strcasecmp(function_name->value, "USINT_TO_STRING")) - return function_usint_to_string; - -if (!strcasecmp(function_name->value, "USINT_TO_BYTE")) - return function_usint_to_byte; - -if (!strcasecmp(function_name->value, "USINT_TO_WORD")) - return function_usint_to_word; - -if (!strcasecmp(function_name->value, "USINT_TO_DWORD")) - return function_usint_to_dword; - -if (!strcasecmp(function_name->value, "USINT_TO_LWORD")) - return function_usint_to_lword; - -if (!strcasecmp(function_name->value, "UINT_TO_BOOL")) - return function_uint_to_bool; - -if (!strcasecmp(function_name->value, "UINT_TO_SINT")) - return function_uint_to_sint; - -if (!strcasecmp(function_name->value, "UINT_TO_INT")) - return function_uint_to_int; - -if (!strcasecmp(function_name->value, "UINT_TO_DINT")) - return function_uint_to_dint; - -if (!strcasecmp(function_name->value, "UINT_TO_LINT")) - return function_uint_to_lint; - -if (!strcasecmp(function_name->value, "UINT_TO_USINT")) - return function_uint_to_usint; - -if (!strcasecmp(function_name->value, "UINT_TO_UDINT")) - return function_uint_to_udint; - -if (!strcasecmp(function_name->value, "UINT_TO_ULINT")) - return function_uint_to_ulint; - -if (!strcasecmp(function_name->value, "UINT_TO_REAL")) - return function_uint_to_real; - -if (!strcasecmp(function_name->value, "UINT_TO_LREAL")) - return function_uint_to_lreal; - -if (!strcasecmp(function_name->value, "UINT_TO_TIME")) - return function_uint_to_time; - -if (!strcasecmp(function_name->value, "UINT_TO_DATE")) - return function_uint_to_date; - -if (!strcasecmp(function_name->value, "UINT_TO_TOD")) - return function_uint_to_tod; - -if (!strcasecmp(function_name->value, "UINT_TO_DT")) - return function_uint_to_dt; - -if (!strcasecmp(function_name->value, "UINT_TO_STRING")) - return function_uint_to_string; - -if (!strcasecmp(function_name->value, "UINT_TO_BYTE")) - return function_uint_to_byte; - -if (!strcasecmp(function_name->value, "UINT_TO_WORD")) - return function_uint_to_word; - -if (!strcasecmp(function_name->value, "UINT_TO_DWORD")) - return function_uint_to_dword; - -if (!strcasecmp(function_name->value, "UINT_TO_LWORD")) - return function_uint_to_lword; - -if (!strcasecmp(function_name->value, "UDINT_TO_BOOL")) - return function_udint_to_bool; - -if (!strcasecmp(function_name->value, "UDINT_TO_SINT")) - return function_udint_to_sint; - -if (!strcasecmp(function_name->value, "UDINT_TO_INT")) - return function_udint_to_int; - -if (!strcasecmp(function_name->value, "UDINT_TO_DINT")) - return function_udint_to_dint; - -if (!strcasecmp(function_name->value, "UDINT_TO_LINT")) - return function_udint_to_lint; - -if (!strcasecmp(function_name->value, "UDINT_TO_USINT")) - return function_udint_to_usint; - -if (!strcasecmp(function_name->value, "UDINT_TO_UINT")) - return function_udint_to_uint; - -if (!strcasecmp(function_name->value, "UDINT_TO_ULINT")) - return function_udint_to_ulint; - -if (!strcasecmp(function_name->value, "UDINT_TO_REAL")) - return function_udint_to_real; - -if (!strcasecmp(function_name->value, "UDINT_TO_LREAL")) - return function_udint_to_lreal; - -if (!strcasecmp(function_name->value, "UDINT_TO_TIME")) - return function_udint_to_time; - -if (!strcasecmp(function_name->value, "UDINT_TO_DATE")) - return function_udint_to_date; - -if (!strcasecmp(function_name->value, "UDINT_TO_TOD")) - return function_udint_to_tod; - -if (!strcasecmp(function_name->value, "UDINT_TO_DT")) - return function_udint_to_dt; - -if (!strcasecmp(function_name->value, "UDINT_TO_STRING")) - return function_udint_to_string; - -if (!strcasecmp(function_name->value, "UDINT_TO_BYTE")) - return function_udint_to_byte; - -if (!strcasecmp(function_name->value, "UDINT_TO_WORD")) - return function_udint_to_word; - -if (!strcasecmp(function_name->value, "UDINT_TO_DWORD")) - return function_udint_to_dword; - -if (!strcasecmp(function_name->value, "UDINT_TO_LWORD")) - return function_udint_to_lword; - -if (!strcasecmp(function_name->value, "ULINT_TO_BOOL")) - return function_ulint_to_bool; - -if (!strcasecmp(function_name->value, "ULINT_TO_SINT")) - return function_ulint_to_sint; - -if (!strcasecmp(function_name->value, "ULINT_TO_INT")) - return function_ulint_to_int; - -if (!strcasecmp(function_name->value, "ULINT_TO_DINT")) - return function_ulint_to_dint; - -if (!strcasecmp(function_name->value, "ULINT_TO_LINT")) - return function_ulint_to_lint; - -if (!strcasecmp(function_name->value, "ULINT_TO_USINT")) - return function_ulint_to_usint; - -if (!strcasecmp(function_name->value, "ULINT_TO_UINT")) - return function_ulint_to_uint; - -if (!strcasecmp(function_name->value, "ULINT_TO_UDINT")) - return function_ulint_to_udint; - -if (!strcasecmp(function_name->value, "ULINT_TO_REAL")) - return function_ulint_to_real; - -if (!strcasecmp(function_name->value, "ULINT_TO_LREAL")) - return function_ulint_to_lreal; - -if (!strcasecmp(function_name->value, "ULINT_TO_TIME")) - return function_ulint_to_time; - -if (!strcasecmp(function_name->value, "ULINT_TO_DATE")) - return function_ulint_to_date; - -if (!strcasecmp(function_name->value, "ULINT_TO_TOD")) - return function_ulint_to_tod; - -if (!strcasecmp(function_name->value, "ULINT_TO_DT")) - return function_ulint_to_dt; - -if (!strcasecmp(function_name->value, "ULINT_TO_STRING")) - return function_ulint_to_string; - -if (!strcasecmp(function_name->value, "ULINT_TO_BYTE")) - return function_ulint_to_byte; - -if (!strcasecmp(function_name->value, "ULINT_TO_WORD")) - return function_ulint_to_word; - -if (!strcasecmp(function_name->value, "ULINT_TO_DWORD")) - return function_ulint_to_dword; - -if (!strcasecmp(function_name->value, "ULINT_TO_LWORD")) - return function_ulint_to_lword; - -if (!strcasecmp(function_name->value, "REAL_TO_BOOL")) - return function_real_to_bool; - -if (!strcasecmp(function_name->value, "REAL_TO_SINT")) - return function_real_to_sint; - -if (!strcasecmp(function_name->value, "REAL_TO_INT")) - return function_real_to_int; - -if (!strcasecmp(function_name->value, "REAL_TO_DINT")) - return function_real_to_dint; - -if (!strcasecmp(function_name->value, "REAL_TO_LINT")) - return function_real_to_lint; - -if (!strcasecmp(function_name->value, "REAL_TO_USINT")) - return function_real_to_usint; - -if (!strcasecmp(function_name->value, "REAL_TO_UINT")) - return function_real_to_uint; - -if (!strcasecmp(function_name->value, "REAL_TO_UDINT")) - return function_real_to_udint; - -if (!strcasecmp(function_name->value, "REAL_TO_ULINT")) - return function_real_to_ulint; - -if (!strcasecmp(function_name->value, "REAL_TO_LREAL")) - return function_real_to_lreal; - -if (!strcasecmp(function_name->value, "REAL_TO_TIME")) - return function_real_to_time; - -if (!strcasecmp(function_name->value, "REAL_TO_DATE")) - return function_real_to_date; - -if (!strcasecmp(function_name->value, "REAL_TO_TOD")) - return function_real_to_tod; - -if (!strcasecmp(function_name->value, "REAL_TO_DT")) - return function_real_to_dt; - -if (!strcasecmp(function_name->value, "REAL_TO_STRING")) - return function_real_to_string; - -if (!strcasecmp(function_name->value, "REAL_TO_BYTE")) - return function_real_to_byte; - -if (!strcasecmp(function_name->value, "REAL_TO_WORD")) - return function_real_to_word; - -if (!strcasecmp(function_name->value, "REAL_TO_DWORD")) - return function_real_to_dword; - -if (!strcasecmp(function_name->value, "REAL_TO_LWORD")) - return function_real_to_lword; - -if (!strcasecmp(function_name->value, "LREAL_TO_BOOL")) - return function_lreal_to_bool; - -if (!strcasecmp(function_name->value, "LREAL_TO_SINT")) - return function_lreal_to_sint; - -if (!strcasecmp(function_name->value, "LREAL_TO_INT")) - return function_lreal_to_int; - -if (!strcasecmp(function_name->value, "LREAL_TO_DINT")) - return function_lreal_to_dint; - -if (!strcasecmp(function_name->value, "LREAL_TO_LINT")) - return function_lreal_to_lint; - -if (!strcasecmp(function_name->value, "LREAL_TO_USINT")) - return function_lreal_to_usint; - -if (!strcasecmp(function_name->value, "LREAL_TO_UINT")) - return function_lreal_to_uint; - -if (!strcasecmp(function_name->value, "LREAL_TO_UDINT")) - return function_lreal_to_udint; - -if (!strcasecmp(function_name->value, "LREAL_TO_ULINT")) - return function_lreal_to_ulint; - -if (!strcasecmp(function_name->value, "LREAL_TO_REAL")) - return function_lreal_to_real; - -if (!strcasecmp(function_name->value, "LREAL_TO_TIME")) - return function_lreal_to_time; - -if (!strcasecmp(function_name->value, "LREAL_TO_DATE")) - return function_lreal_to_date; - -if (!strcasecmp(function_name->value, "LREAL_TO_TOD")) - return function_lreal_to_tod; - -if (!strcasecmp(function_name->value, "LREAL_TO_DT")) - return function_lreal_to_dt; - -if (!strcasecmp(function_name->value, "LREAL_TO_STRING")) - return function_lreal_to_string; - -if (!strcasecmp(function_name->value, "LREAL_TO_BYTE")) - return function_lreal_to_byte; - -if (!strcasecmp(function_name->value, "LREAL_TO_WORD")) - return function_lreal_to_word; - -if (!strcasecmp(function_name->value, "LREAL_TO_DWORD")) - return function_lreal_to_dword; - -if (!strcasecmp(function_name->value, "LREAL_TO_LWORD")) - return function_lreal_to_lword; - -if (!strcasecmp(function_name->value, "TIME_TO_SINT")) - return function_time_to_sint; - -if (!strcasecmp(function_name->value, "TIME_TO_INT")) - return function_time_to_int; - -if (!strcasecmp(function_name->value, "TIME_TO_DINT")) - return function_time_to_dint; - -if (!strcasecmp(function_name->value, "TIME_TO_LINT")) - return function_time_to_lint; - -if (!strcasecmp(function_name->value, "TIME_TO_USINT")) - return function_time_to_usint; - -if (!strcasecmp(function_name->value, "TIME_TO_UINT")) - return function_time_to_uint; - -if (!strcasecmp(function_name->value, "TIME_TO_UDINT")) - return function_time_to_udint; - -if (!strcasecmp(function_name->value, "TIME_TO_ULINT")) - return function_time_to_ulint; - -if (!strcasecmp(function_name->value, "TIME_TO_REAL")) - return function_time_to_real; - -if (!strcasecmp(function_name->value, "TIME_TO_LREAL")) - return function_time_to_lreal; - -if (!strcasecmp(function_name->value, "TIME_TO_STRING")) - return function_time_to_string; - -if (!strcasecmp(function_name->value, "TIME_TO_BYTE")) - return function_time_to_byte; - -if (!strcasecmp(function_name->value, "TIME_TO_WORD")) - return function_time_to_word; - -if (!strcasecmp(function_name->value, "TIME_TO_DWORD")) - return function_time_to_dword; - -if (!strcasecmp(function_name->value, "TIME_TO_LWORD")) - return function_time_to_lword; - -if (!strcasecmp(function_name->value, "DATE_TO_SINT")) - return function_date_to_sint; - -if (!strcasecmp(function_name->value, "DATE_TO_INT")) - return function_date_to_int; - -if (!strcasecmp(function_name->value, "DATE_TO_DINT")) - return function_date_to_dint; - -if (!strcasecmp(function_name->value, "DATE_TO_LINT")) - return function_date_to_lint; - -if (!strcasecmp(function_name->value, "DATE_TO_USINT")) - return function_date_to_usint; - -if (!strcasecmp(function_name->value, "DATE_TO_UINT")) - return function_date_to_uint; - -if (!strcasecmp(function_name->value, "DATE_TO_UDINT")) - return function_date_to_udint; - -if (!strcasecmp(function_name->value, "DATE_TO_ULINT")) - return function_date_to_ulint; - -if (!strcasecmp(function_name->value, "DATE_TO_REAL")) - return function_date_to_real; - -if (!strcasecmp(function_name->value, "DATE_TO_LREAL")) - return function_date_to_lreal; - -if (!strcasecmp(function_name->value, "DATE_TO_STRING")) - return function_date_to_string; - -if (!strcasecmp(function_name->value, "DATE_TO_BYTE")) - return function_date_to_byte; - -if (!strcasecmp(function_name->value, "DATE_TO_WORD")) - return function_date_to_word; - -if (!strcasecmp(function_name->value, "DATE_TO_DWORD")) - return function_date_to_dword; - -if (!strcasecmp(function_name->value, "DATE_TO_LWORD")) - return function_date_to_lword; - -if (!strcasecmp(function_name->value, "TOD_TO_SINT")) - return function_tod_to_sint; - -if (!strcasecmp(function_name->value, "TOD_TO_INT")) - return function_tod_to_int; - -if (!strcasecmp(function_name->value, "TOD_TO_DINT")) - return function_tod_to_dint; - -if (!strcasecmp(function_name->value, "TOD_TO_LINT")) - return function_tod_to_lint; - -if (!strcasecmp(function_name->value, "TOD_TO_USINT")) - return function_tod_to_usint; - -if (!strcasecmp(function_name->value, "TOD_TO_UINT")) - return function_tod_to_uint; - -if (!strcasecmp(function_name->value, "TOD_TO_UDINT")) - return function_tod_to_udint; - -if (!strcasecmp(function_name->value, "TOD_TO_ULINT")) - return function_tod_to_ulint; - -if (!strcasecmp(function_name->value, "TOD_TO_REAL")) - return function_tod_to_real; - -if (!strcasecmp(function_name->value, "TOD_TO_LREAL")) - return function_tod_to_lreal; - -if (!strcasecmp(function_name->value, "TOD_TO_STRING")) - return function_tod_to_string; - -if (!strcasecmp(function_name->value, "TOD_TO_BYTE")) - return function_tod_to_byte; - -if (!strcasecmp(function_name->value, "TOD_TO_WORD")) - return function_tod_to_word; - -if (!strcasecmp(function_name->value, "TOD_TO_DWORD")) - return function_tod_to_dword; - -if (!strcasecmp(function_name->value, "TOD_TO_LWORD")) - return function_tod_to_lword; - -if (!strcasecmp(function_name->value, "DT_TO_SINT")) - return function_dt_to_sint; - -if (!strcasecmp(function_name->value, "DT_TO_INT")) - return function_dt_to_int; - -if (!strcasecmp(function_name->value, "DT_TO_DINT")) - return function_dt_to_dint; - -if (!strcasecmp(function_name->value, "DT_TO_LINT")) - return function_dt_to_lint; - -if (!strcasecmp(function_name->value, "DT_TO_USINT")) - return function_dt_to_usint; - -if (!strcasecmp(function_name->value, "DT_TO_UINT")) - return function_dt_to_uint; - -if (!strcasecmp(function_name->value, "DT_TO_UDINT")) - return function_dt_to_udint; - -if (!strcasecmp(function_name->value, "DT_TO_ULINT")) - return function_dt_to_ulint; - -if (!strcasecmp(function_name->value, "DT_TO_REAL")) - return function_dt_to_real; - -if (!strcasecmp(function_name->value, "DT_TO_LREAL")) - return function_dt_to_lreal; - -if (!strcasecmp(function_name->value, "DT_TO_STRING")) - return function_dt_to_string; - -if (!strcasecmp(function_name->value, "DT_TO_BYTE")) - return function_dt_to_byte; - -if (!strcasecmp(function_name->value, "DT_TO_WORD")) - return function_dt_to_word; - -if (!strcasecmp(function_name->value, "DT_TO_DWORD")) - return function_dt_to_dword; - -if (!strcasecmp(function_name->value, "DT_TO_LWORD")) - return function_dt_to_lword; - -if (!strcasecmp(function_name->value, "STRING_TO_BOOL")) - return function_string_to_bool; - -if (!strcasecmp(function_name->value, "STRING_TO_SINT")) - return function_string_to_sint; - -if (!strcasecmp(function_name->value, "STRING_TO_INT")) - return function_string_to_int; - -if (!strcasecmp(function_name->value, "STRING_TO_DINT")) - return function_string_to_dint; - -if (!strcasecmp(function_name->value, "STRING_TO_LINT")) - return function_string_to_lint; - -if (!strcasecmp(function_name->value, "STRING_TO_USINT")) - return function_string_to_usint; - -if (!strcasecmp(function_name->value, "STRING_TO_UINT")) - return function_string_to_uint; - -if (!strcasecmp(function_name->value, "STRING_TO_UDINT")) - return function_string_to_udint; - -if (!strcasecmp(function_name->value, "STRING_TO_ULINT")) - return function_string_to_ulint; - -if (!strcasecmp(function_name->value, "STRING_TO_REAL")) - return function_string_to_real; - -if (!strcasecmp(function_name->value, "STRING_TO_LREAL")) - return function_string_to_lreal; - -if (!strcasecmp(function_name->value, "STRING_TO_TIME")) - return function_string_to_time; - -if (!strcasecmp(function_name->value, "STRING_TO_DATE")) - return function_string_to_date; - -if (!strcasecmp(function_name->value, "STRING_TO_TOD")) - return function_string_to_tod; - -if (!strcasecmp(function_name->value, "STRING_TO_DT")) - return function_string_to_dt; - -if (!strcasecmp(function_name->value, "STRING_TO_BYTE")) - return function_string_to_byte; - -if (!strcasecmp(function_name->value, "STRING_TO_WORD")) - return function_string_to_word; - -if (!strcasecmp(function_name->value, "STRING_TO_DWORD")) - return function_string_to_dword; - -if (!strcasecmp(function_name->value, "STRING_TO_LWORD")) - return function_string_to_lword; - -if (!strcasecmp(function_name->value, "BYTE_TO_BOOL")) - return function_byte_to_bool; - -if (!strcasecmp(function_name->value, "BYTE_TO_SINT")) - return function_byte_to_sint; - -if (!strcasecmp(function_name->value, "BYTE_TO_INT")) - return function_byte_to_int; - -if (!strcasecmp(function_name->value, "BYTE_TO_DINT")) - return function_byte_to_dint; - -if (!strcasecmp(function_name->value, "BYTE_TO_LINT")) - return function_byte_to_lint; - -if (!strcasecmp(function_name->value, "BYTE_TO_USINT")) - return function_byte_to_usint; - -if (!strcasecmp(function_name->value, "BYTE_TO_UINT")) - return function_byte_to_uint; - -if (!strcasecmp(function_name->value, "BYTE_TO_UDINT")) - return function_byte_to_udint; - -if (!strcasecmp(function_name->value, "BYTE_TO_ULINT")) - return function_byte_to_ulint; - -if (!strcasecmp(function_name->value, "BYTE_TO_REAL")) - return function_byte_to_real; - -if (!strcasecmp(function_name->value, "BYTE_TO_LREAL")) - return function_byte_to_lreal; - -if (!strcasecmp(function_name->value, "BYTE_TO_TIME")) - return function_byte_to_time; - -if (!strcasecmp(function_name->value, "BYTE_TO_DATE")) - return function_byte_to_date; - -if (!strcasecmp(function_name->value, "BYTE_TO_TOD")) - return function_byte_to_tod; - -if (!strcasecmp(function_name->value, "BYTE_TO_DT")) - return function_byte_to_dt; - -if (!strcasecmp(function_name->value, "BYTE_TO_STRING")) - return function_byte_to_string; - -if (!strcasecmp(function_name->value, "BYTE_TO_WORD")) - return function_byte_to_word; - -if (!strcasecmp(function_name->value, "BYTE_TO_DWORD")) - return function_byte_to_dword; - -if (!strcasecmp(function_name->value, "BYTE_TO_LWORD")) - return function_byte_to_lword; - -if (!strcasecmp(function_name->value, "WORD_TO_BOOL")) - return function_word_to_bool; - -if (!strcasecmp(function_name->value, "WORD_TO_SINT")) - return function_word_to_sint; - -if (!strcasecmp(function_name->value, "WORD_TO_INT")) - return function_word_to_int; - -if (!strcasecmp(function_name->value, "WORD_TO_DINT")) - return function_word_to_dint; - -if (!strcasecmp(function_name->value, "WORD_TO_LINT")) - return function_word_to_lint; - -if (!strcasecmp(function_name->value, "WORD_TO_USINT")) - return function_word_to_usint; - -if (!strcasecmp(function_name->value, "WORD_TO_UINT")) - return function_word_to_uint; - -if (!strcasecmp(function_name->value, "WORD_TO_UDINT")) - return function_word_to_udint; - -if (!strcasecmp(function_name->value, "WORD_TO_ULINT")) - return function_word_to_ulint; - -if (!strcasecmp(function_name->value, "WORD_TO_REAL")) - return function_word_to_real; - -if (!strcasecmp(function_name->value, "WORD_TO_LREAL")) - return function_word_to_lreal; - -if (!strcasecmp(function_name->value, "WORD_TO_TIME")) - return function_word_to_time; - -if (!strcasecmp(function_name->value, "WORD_TO_DATE")) - return function_word_to_date; - -if (!strcasecmp(function_name->value, "WORD_TO_TOD")) - return function_word_to_tod; - -if (!strcasecmp(function_name->value, "WORD_TO_DT")) - return function_word_to_dt; - -if (!strcasecmp(function_name->value, "WORD_TO_STRING")) - return function_word_to_string; - -if (!strcasecmp(function_name->value, "WORD_TO_BYTE")) - return function_word_to_byte; - -if (!strcasecmp(function_name->value, "WORD_TO_DWORD")) - return function_word_to_dword; - -if (!strcasecmp(function_name->value, "WORD_TO_LWORD")) - return function_word_to_lword; - -if (!strcasecmp(function_name->value, "DWORD_TO_BOOL")) - return function_dword_to_bool; - -if (!strcasecmp(function_name->value, "DWORD_TO_SINT")) - return function_dword_to_sint; - -if (!strcasecmp(function_name->value, "DWORD_TO_INT")) - return function_dword_to_int; - -if (!strcasecmp(function_name->value, "DWORD_TO_DINT")) - return function_dword_to_dint; - -if (!strcasecmp(function_name->value, "DWORD_TO_LINT")) - return function_dword_to_lint; - -if (!strcasecmp(function_name->value, "DWORD_TO_USINT")) - return function_dword_to_usint; - -if (!strcasecmp(function_name->value, "DWORD_TO_UINT")) - return function_dword_to_uint; - -if (!strcasecmp(function_name->value, "DWORD_TO_UDINT")) - return function_dword_to_udint; - -if (!strcasecmp(function_name->value, "DWORD_TO_ULINT")) - return function_dword_to_ulint; - -if (!strcasecmp(function_name->value, "DWORD_TO_REAL")) - return function_dword_to_real; - -if (!strcasecmp(function_name->value, "DWORD_TO_LREAL")) - return function_dword_to_lreal; - -if (!strcasecmp(function_name->value, "DWORD_TO_TIME")) - return function_dword_to_time; - -if (!strcasecmp(function_name->value, "DWORD_TO_DATE")) - return function_dword_to_date; - -if (!strcasecmp(function_name->value, "DWORD_TO_TOD")) - return function_dword_to_tod; - -if (!strcasecmp(function_name->value, "DWORD_TO_DT")) - return function_dword_to_dt; - -if (!strcasecmp(function_name->value, "DWORD_TO_STRING")) - return function_dword_to_string; - -if (!strcasecmp(function_name->value, "DWORD_TO_BYTE")) - return function_dword_to_byte; - -if (!strcasecmp(function_name->value, "DWORD_TO_WORD")) - return function_dword_to_word; - -if (!strcasecmp(function_name->value, "DWORD_TO_LWORD")) - return function_dword_to_lword; - -if (!strcasecmp(function_name->value, "LWORD_TO_BOOL")) - return function_lword_to_bool; - -if (!strcasecmp(function_name->value, "LWORD_TO_SINT")) - return function_lword_to_sint; - -if (!strcasecmp(function_name->value, "LWORD_TO_INT")) - return function_lword_to_int; - -if (!strcasecmp(function_name->value, "LWORD_TO_DINT")) - return function_lword_to_dint; - -if (!strcasecmp(function_name->value, "LWORD_TO_LINT")) - return function_lword_to_lint; - -if (!strcasecmp(function_name->value, "LWORD_TO_USINT")) - return function_lword_to_usint; - -if (!strcasecmp(function_name->value, "LWORD_TO_UINT")) - return function_lword_to_uint; - -if (!strcasecmp(function_name->value, "LWORD_TO_UDINT")) - return function_lword_to_udint; - -if (!strcasecmp(function_name->value, "LWORD_TO_ULINT")) - return function_lword_to_ulint; - -if (!strcasecmp(function_name->value, "LWORD_TO_REAL")) - return function_lword_to_real; - -if (!strcasecmp(function_name->value, "LWORD_TO_LREAL")) - return function_lword_to_lreal; - -if (!strcasecmp(function_name->value, "LWORD_TO_TIME")) - return function_lword_to_time; - -if (!strcasecmp(function_name->value, "LWORD_TO_DATE")) - return function_lword_to_date; - -if (!strcasecmp(function_name->value, "LWORD_TO_TOD")) - return function_lword_to_tod; - -if (!strcasecmp(function_name->value, "LWORD_TO_DT")) - return function_lword_to_dt; - -if (!strcasecmp(function_name->value, "LWORD_TO_STRING")) - return function_lword_to_string; - -if (!strcasecmp(function_name->value, "LWORD_TO_BYTE")) - return function_lword_to_byte; - -if (!strcasecmp(function_name->value, "LWORD_TO_WORD")) - return function_lword_to_word; - -if (!strcasecmp(function_name->value, "LWORD_TO_DWORD")) - return function_lword_to_dword; - -if (!strcasecmp(function_name->value, "TRUNC")) - return function_trunc; - -if (!strcasecmp(function_name->value, "BCD_TO_USINT")) - return function_bcd_to_usint; - -if (!strcasecmp(function_name->value, "BCD_TO_UINT")) - return function_bcd_to_uint; - -if (!strcasecmp(function_name->value, "BCD_TO_UDINT")) - return function_bcd_to_udint; - -if (!strcasecmp(function_name->value, "BCD_TO_ULINT")) - return function_bcd_to_ulint; - -if (!strcasecmp(function_name->value, "USINT_TO_BCD")) - return function_usint_to_bcd; - -if (!strcasecmp(function_name->value, "UINT_TO_BCD")) - return function_uint_to_bcd; - -if (!strcasecmp(function_name->value, "UDINT_TO_BCD")) - return function_udint_to_bcd; - -if (!strcasecmp(function_name->value, "ULINT_TO_BCD")) - return function_ulint_to_bcd; - -if (!strcasecmp(function_name->value, "DATE_AND_TIME_TO_TIME_OF_DAY")) - return function_date_and_time_to_time_of_day; - -if (!strcasecmp(function_name->value, "DATE_AND_TIME_TO_DATE")) - return function_date_and_time_to_date; - -if (!strcasecmp(function_name->value, "ABS")) - return function_abs; - -if (!strcasecmp(function_name->value, "SQRT")) - return function_sqrt; - -if (!strcasecmp(function_name->value, "LN")) - return function_ln; - -if (!strcasecmp(function_name->value, "LOG")) - return function_log; - -if (!strcasecmp(function_name->value, "EXP")) - return function_exp; - -if (!strcasecmp(function_name->value, "SIN")) - return function_sin; - -if (!strcasecmp(function_name->value, "COS")) - return function_cos; - -if (!strcasecmp(function_name->value, "TAN")) - return function_tan; - -if (!strcasecmp(function_name->value, "ASIN")) - return function_asin; - -if (!strcasecmp(function_name->value, "ACOS")) - return function_acos; - -if (!strcasecmp(function_name->value, "ATAN")) - return function_atan; - -if (!strcasecmp(function_name->value, "ADD")) - return function_add; - -if (!strcasecmp(function_name->value, "MUL")) - return function_mul; - -if (!strcasecmp(function_name->value, "SUB")) - return function_sub; - -if (!strcasecmp(function_name->value, "DIV")) - return function_div; - -if (!strcasecmp(function_name->value, "MOD")) - return function_mod; - -if (!strcasecmp(function_name->value, "EXPT")) - return function_expt; - -if (!strcasecmp(function_name->value, "MOVE")) - return function_move; - -if (!strcasecmp(function_name->value, "SHL")) - return function_shl; - -if (!strcasecmp(function_name->value, "SHR")) - return function_shr; - -if (!strcasecmp(function_name->value, "ROR")) - return function_ror; - -if (!strcasecmp(function_name->value, "ROL")) - return function_rol; - -if (!strcasecmp(function_name->value, "AND")) - return function_and; - -if (!strcasecmp(function_name->value, "OR")) - return function_or; - -if (!strcasecmp(function_name->value, "XOR")) - return function_xor; - -if (!strcasecmp(function_name->value, "NOT")) - return function_not; - -if (!strcasecmp(function_name->value, "SEL")) - return function_sel; - -if (!strcasecmp(function_name->value, "MAX")) - return function_max; - -if (!strcasecmp(function_name->value, "MIN")) - return function_min; - -if (!strcasecmp(function_name->value, "LIMIT")) - return function_limit; - -if (!strcasecmp(function_name->value, "MUX")) - return function_mux; - -if (!strcasecmp(function_name->value, "GT")) - return function_gt; - -if (!strcasecmp(function_name->value, "GE")) - return function_ge; - -if (!strcasecmp(function_name->value, "EQ")) - return function_eq; - -if (!strcasecmp(function_name->value, "LT")) - return function_lt; - -if (!strcasecmp(function_name->value, "LE")) - return function_le; - -if (!strcasecmp(function_name->value, "NE")) - return function_ne; - -if (!strcasecmp(function_name->value, "LEN")) - return function_len; - -if (!strcasecmp(function_name->value, "LEFT")) - return function_left; - -if (!strcasecmp(function_name->value, "RIGHT")) - return function_right; - -if (!strcasecmp(function_name->value, "MID")) - return function_mid; - -if (!strcasecmp(function_name->value, "CONCAT")) - return function_concat; - -if (!strcasecmp(function_name->value, "INSERT")) - return function_insert; - -if (!strcasecmp(function_name->value, "DELETE")) - return function_delete; - -if (!strcasecmp(function_name->value, "REPLACE")) - return function_replace; - -if (!strcasecmp(function_name->value, "FIND")) - return function_find; - - else return function_none; -} - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/il_code_gen.c --- a/stage4/generate_cc/il_code_gen.c Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,15289 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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 lib - * generated code, do not edit by hand - */ -switch(current_function_type){ - -/**** - *BOOL_TO_SINT - */ - case function_bool_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_sint*/ - break; - -/**** - *BOOL_TO_INT - */ - case function_bool_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_int*/ - break; - -/**** - *BOOL_TO_DINT - */ - case function_bool_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_dint*/ - break; - -/**** - *BOOL_TO_LINT - */ - case function_bool_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_lint*/ - break; - -/**** - *BOOL_TO_USINT - */ - case function_bool_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_usint*/ - break; - -/**** - *BOOL_TO_UINT - */ - case function_bool_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_uint*/ - break; - -/**** - *BOOL_TO_UDINT - */ - case function_bool_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_udint*/ - break; - -/**** - *BOOL_TO_ULINT - */ - case function_bool_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_ulint*/ - break; - -/**** - *BOOL_TO_REAL - */ - case function_bool_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_real*/ - break; - -/**** - *BOOL_TO_LREAL - */ - case function_bool_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_lreal*/ - break; - -/**** - *BOOL_TO_TIME - */ - case function_bool_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_time*/ - break; - -/**** - *BOOL_TO_DATE - */ - case function_bool_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_date*/ - break; - -/**** - *BOOL_TO_TOD - */ - case function_bool_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_tod*/ - break; - -/**** - *BOOL_TO_DT - */ - case function_bool_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_dt*/ - break; - -/**** - *BOOL_TO_STRING - */ - case function_bool_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bool_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_string*/ - break; - -/**** - *BOOL_TO_BYTE - */ - case function_bool_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_byte*/ - break; - -/**** - *BOOL_TO_WORD - */ - case function_bool_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_word*/ - break; - -/**** - *BOOL_TO_DWORD - */ - case function_bool_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_dword*/ - break; - -/**** - *BOOL_TO_LWORD - */ - case function_bool_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_lword*/ - break; - -/**** - *SINT_TO_BOOL - */ - case function_sint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_bool*/ - break; - -/**** - *SINT_TO_INT - */ - case function_sint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_int*/ - break; - -/**** - *SINT_TO_DINT - */ - case function_sint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_dint*/ - break; - -/**** - *SINT_TO_LINT - */ - case function_sint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_lint*/ - break; - -/**** - *SINT_TO_USINT - */ - case function_sint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_usint*/ - break; - -/**** - *SINT_TO_UINT - */ - case function_sint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_uint*/ - break; - -/**** - *SINT_TO_UDINT - */ - case function_sint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_udint*/ - break; - -/**** - *SINT_TO_ULINT - */ - case function_sint_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_ulint*/ - break; - -/**** - *SINT_TO_REAL - */ - case function_sint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_real*/ - break; - -/**** - *SINT_TO_LREAL - */ - case function_sint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_lreal*/ - break; - -/**** - *SINT_TO_TIME - */ - case function_sint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_time*/ - break; - -/**** - *SINT_TO_DATE - */ - case function_sint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_date*/ - break; - -/**** - *SINT_TO_TOD - */ - case function_sint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_tod*/ - break; - -/**** - *SINT_TO_DT - */ - case function_sint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_dt*/ - break; - -/**** - *SINT_TO_STRING - */ - case function_sint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__sint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_string*/ - break; - -/**** - *SINT_TO_BYTE - */ - case function_sint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_byte*/ - break; - -/**** - *SINT_TO_WORD - */ - case function_sint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_word*/ - break; - -/**** - *SINT_TO_DWORD - */ - case function_sint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_dword*/ - break; - -/**** - *SINT_TO_LWORD - */ - case function_sint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_lword*/ - break; - -/**** - *INT_TO_BOOL - */ - case function_int_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_bool*/ - break; - -/**** - *INT_TO_SINT - */ - case function_int_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_sint*/ - break; - -/**** - *INT_TO_DINT - */ - case function_int_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_dint*/ - break; - -/**** - *INT_TO_LINT - */ - case function_int_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_lint*/ - break; - -/**** - *INT_TO_USINT - */ - case function_int_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_usint*/ - break; - -/**** - *INT_TO_UINT - */ - case function_int_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_uint*/ - break; - -/**** - *INT_TO_UDINT - */ - case function_int_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_udint*/ - break; - -/**** - *INT_TO_ULINT - */ - case function_int_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_ulint*/ - break; - -/**** - *INT_TO_REAL - */ - case function_int_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_real*/ - break; - -/**** - *INT_TO_LREAL - */ - case function_int_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_lreal*/ - break; - -/**** - *INT_TO_TIME - */ - case function_int_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_time*/ - break; - -/**** - *INT_TO_DATE - */ - case function_int_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_date*/ - break; - -/**** - *INT_TO_TOD - */ - case function_int_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_tod*/ - break; - -/**** - *INT_TO_DT - */ - case function_int_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_dt*/ - break; - -/**** - *INT_TO_STRING - */ - case function_int_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__sint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_string*/ - break; - -/**** - *INT_TO_BYTE - */ - case function_int_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_byte*/ - break; - -/**** - *INT_TO_WORD - */ - case function_int_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_word*/ - break; - -/**** - *INT_TO_DWORD - */ - case function_int_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_dword*/ - break; - -/**** - *INT_TO_LWORD - */ - case function_int_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_lword*/ - break; - -/**** - *DINT_TO_BOOL - */ - case function_dint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_bool*/ - break; - -/**** - *DINT_TO_SINT - */ - case function_dint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_sint*/ - break; - -/**** - *DINT_TO_INT - */ - case function_dint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_int*/ - break; - -/**** - *DINT_TO_LINT - */ - case function_dint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_lint*/ - break; - -/**** - *DINT_TO_USINT - */ - case function_dint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_usint*/ - break; - -/**** - *DINT_TO_UINT - */ - case function_dint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_uint*/ - break; - -/**** - *DINT_TO_UDINT - */ - case function_dint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_udint*/ - break; - -/**** - *DINT_TO_ULINT - */ - case function_dint_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_ulint*/ - break; - -/**** - *DINT_TO_REAL - */ - case function_dint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_real*/ - break; - -/**** - *DINT_TO_LREAL - */ - case function_dint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_lreal*/ - break; - -/**** - *DINT_TO_TIME - */ - case function_dint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_time*/ - break; - -/**** - *DINT_TO_DATE - */ - case function_dint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_date*/ - break; - -/**** - *DINT_TO_TOD - */ - case function_dint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_tod*/ - break; - -/**** - *DINT_TO_DT - */ - case function_dint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_dt*/ - break; - -/**** - *DINT_TO_STRING - */ - case function_dint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__sint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_string*/ - break; - -/**** - *DINT_TO_BYTE - */ - case function_dint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_byte*/ - break; - -/**** - *DINT_TO_WORD - */ - case function_dint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_word*/ - break; - -/**** - *DINT_TO_DWORD - */ - case function_dint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_dword*/ - break; - -/**** - *DINT_TO_LWORD - */ - case function_dint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_lword*/ - break; - -/**** - *LINT_TO_BOOL - */ - case function_lint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_bool*/ - break; - -/**** - *LINT_TO_SINT - */ - case function_lint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_sint*/ - break; - -/**** - *LINT_TO_INT - */ - case function_lint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_int*/ - break; - -/**** - *LINT_TO_DINT - */ - case function_lint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_dint*/ - break; - -/**** - *LINT_TO_USINT - */ - case function_lint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_usint*/ - break; - -/**** - *LINT_TO_UINT - */ - case function_lint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_uint*/ - break; - -/**** - *LINT_TO_UDINT - */ - case function_lint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_udint*/ - break; - -/**** - *LINT_TO_ULINT - */ - case function_lint_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_ulint*/ - break; - -/**** - *LINT_TO_REAL - */ - case function_lint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_real*/ - break; - -/**** - *LINT_TO_LREAL - */ - case function_lint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_lreal*/ - break; - -/**** - *LINT_TO_TIME - */ - case function_lint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_time*/ - break; - -/**** - *LINT_TO_DATE - */ - case function_lint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_date*/ - break; - -/**** - *LINT_TO_TOD - */ - case function_lint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_tod*/ - break; - -/**** - *LINT_TO_DT - */ - case function_lint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_dt*/ - break; - -/**** - *LINT_TO_STRING - */ - case function_lint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__sint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_string*/ - break; - -/**** - *LINT_TO_BYTE - */ - case function_lint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_byte*/ - break; - -/**** - *LINT_TO_WORD - */ - case function_lint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_word*/ - break; - -/**** - *LINT_TO_DWORD - */ - case function_lint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_dword*/ - break; - -/**** - *LINT_TO_LWORD - */ - case function_lint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_lword*/ - break; - -/**** - *USINT_TO_BOOL - */ - case function_usint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_bool*/ - break; - -/**** - *USINT_TO_SINT - */ - case function_usint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_sint*/ - break; - -/**** - *USINT_TO_INT - */ - case function_usint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_int*/ - break; - -/**** - *USINT_TO_DINT - */ - case function_usint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_dint*/ - break; - -/**** - *USINT_TO_LINT - */ - case function_usint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_lint*/ - break; - -/**** - *USINT_TO_UINT - */ - case function_usint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_uint*/ - break; - -/**** - *USINT_TO_UDINT - */ - case function_usint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_udint*/ - break; - -/**** - *USINT_TO_ULINT - */ - case function_usint_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_ulint*/ - break; - -/**** - *USINT_TO_REAL - */ - case function_usint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_real*/ - break; - -/**** - *USINT_TO_LREAL - */ - case function_usint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_lreal*/ - break; - -/**** - *USINT_TO_TIME - */ - case function_usint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_time*/ - break; - -/**** - *USINT_TO_DATE - */ - case function_usint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_date*/ - break; - -/**** - *USINT_TO_TOD - */ - case function_usint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_tod*/ - break; - -/**** - *USINT_TO_DT - */ - case function_usint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_dt*/ - break; - -/**** - *USINT_TO_STRING - */ - case function_usint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_string*/ - break; - -/**** - *USINT_TO_BYTE - */ - case function_usint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_byte*/ - break; - -/**** - *USINT_TO_WORD - */ - case function_usint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_word*/ - break; - -/**** - *USINT_TO_DWORD - */ - case function_usint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_dword*/ - break; - -/**** - *USINT_TO_LWORD - */ - case function_usint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_lword*/ - break; - -/**** - *UINT_TO_BOOL - */ - case function_uint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_bool*/ - break; - -/**** - *UINT_TO_SINT - */ - case function_uint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_sint*/ - break; - -/**** - *UINT_TO_INT - */ - case function_uint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_int*/ - break; - -/**** - *UINT_TO_DINT - */ - case function_uint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_dint*/ - break; - -/**** - *UINT_TO_LINT - */ - case function_uint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_lint*/ - break; - -/**** - *UINT_TO_USINT - */ - case function_uint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_usint*/ - break; - -/**** - *UINT_TO_UDINT - */ - case function_uint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_udint*/ - break; - -/**** - *UINT_TO_ULINT - */ - case function_uint_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_ulint*/ - break; - -/**** - *UINT_TO_REAL - */ - case function_uint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_real*/ - break; - -/**** - *UINT_TO_LREAL - */ - case function_uint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_lreal*/ - break; - -/**** - *UINT_TO_TIME - */ - case function_uint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_time*/ - break; - -/**** - *UINT_TO_DATE - */ - case function_uint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_date*/ - break; - -/**** - *UINT_TO_TOD - */ - case function_uint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_tod*/ - break; - -/**** - *UINT_TO_DT - */ - case function_uint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_dt*/ - break; - -/**** - *UINT_TO_STRING - */ - case function_uint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_string*/ - break; - -/**** - *UINT_TO_BYTE - */ - case function_uint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_byte*/ - break; - -/**** - *UINT_TO_WORD - */ - case function_uint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_word*/ - break; - -/**** - *UINT_TO_DWORD - */ - case function_uint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_dword*/ - break; - -/**** - *UINT_TO_LWORD - */ - case function_uint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_lword*/ - break; - -/**** - *UDINT_TO_BOOL - */ - case function_udint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_bool*/ - break; - -/**** - *UDINT_TO_SINT - */ - case function_udint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_sint*/ - break; - -/**** - *UDINT_TO_INT - */ - case function_udint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_int*/ - break; - -/**** - *UDINT_TO_DINT - */ - case function_udint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_dint*/ - break; - -/**** - *UDINT_TO_LINT - */ - case function_udint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_lint*/ - break; - -/**** - *UDINT_TO_USINT - */ - case function_udint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_usint*/ - break; - -/**** - *UDINT_TO_UINT - */ - case function_udint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_uint*/ - break; - -/**** - *UDINT_TO_ULINT - */ - case function_udint_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_ulint*/ - break; - -/**** - *UDINT_TO_REAL - */ - case function_udint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_real*/ - break; - -/**** - *UDINT_TO_LREAL - */ - case function_udint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_lreal*/ - break; - -/**** - *UDINT_TO_TIME - */ - case function_udint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_time*/ - break; - -/**** - *UDINT_TO_DATE - */ - case function_udint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_date*/ - break; - -/**** - *UDINT_TO_TOD - */ - case function_udint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_tod*/ - break; - -/**** - *UDINT_TO_DT - */ - case function_udint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_dt*/ - break; - -/**** - *UDINT_TO_STRING - */ - case function_udint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_string*/ - break; - -/**** - *UDINT_TO_BYTE - */ - case function_udint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_byte*/ - break; - -/**** - *UDINT_TO_WORD - */ - case function_udint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_word*/ - break; - -/**** - *UDINT_TO_DWORD - */ - case function_udint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_dword*/ - break; - -/**** - *UDINT_TO_LWORD - */ - case function_udint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_lword*/ - break; - -/**** - *ULINT_TO_BOOL - */ - case function_ulint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_bool*/ - break; - -/**** - *ULINT_TO_SINT - */ - case function_ulint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_sint*/ - break; - -/**** - *ULINT_TO_INT - */ - case function_ulint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_int*/ - break; - -/**** - *ULINT_TO_DINT - */ - case function_ulint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_dint*/ - break; - -/**** - *ULINT_TO_LINT - */ - case function_ulint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_lint*/ - break; - -/**** - *ULINT_TO_USINT - */ - case function_ulint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_usint*/ - break; - -/**** - *ULINT_TO_UINT - */ - case function_ulint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_uint*/ - break; - -/**** - *ULINT_TO_UDINT - */ - case function_ulint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_udint*/ - break; - -/**** - *ULINT_TO_REAL - */ - case function_ulint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_real*/ - break; - -/**** - *ULINT_TO_LREAL - */ - case function_ulint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_lreal*/ - break; - -/**** - *ULINT_TO_TIME - */ - case function_ulint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_time*/ - break; - -/**** - *ULINT_TO_DATE - */ - case function_ulint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_date*/ - break; - -/**** - *ULINT_TO_TOD - */ - case function_ulint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_tod*/ - break; - -/**** - *ULINT_TO_DT - */ - case function_ulint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_dt*/ - break; - -/**** - *ULINT_TO_STRING - */ - case function_ulint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_string*/ - break; - -/**** - *ULINT_TO_BYTE - */ - case function_ulint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_byte*/ - break; - -/**** - *ULINT_TO_WORD - */ - case function_ulint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_word*/ - break; - -/**** - *ULINT_TO_DWORD - */ - case function_ulint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_dword*/ - break; - -/**** - *ULINT_TO_LWORD - */ - case function_ulint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_lword*/ - break; - -/**** - *REAL_TO_BOOL - */ - case function_real_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_bool*/ - break; - -/**** - *REAL_TO_SINT - */ - case function_real_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_sint*/ - break; - -/**** - *REAL_TO_INT - */ - case function_real_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_int*/ - break; - -/**** - *REAL_TO_DINT - */ - case function_real_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_dint*/ - break; - -/**** - *REAL_TO_LINT - */ - case function_real_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_lint*/ - break; - -/**** - *REAL_TO_USINT - */ - case function_real_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_usint*/ - break; - -/**** - *REAL_TO_UINT - */ - case function_real_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_uint*/ - break; - -/**** - *REAL_TO_UDINT - */ - case function_real_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_udint*/ - break; - -/**** - *REAL_TO_ULINT - */ - case function_real_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_ulint*/ - break; - -/**** - *REAL_TO_LREAL - */ - case function_real_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_lreal*/ - break; - -/**** - *REAL_TO_TIME - */ - case function_real_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_time*/ - break; - -/**** - *REAL_TO_DATE - */ - case function_real_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_date*/ - break; - -/**** - *REAL_TO_TOD - */ - case function_real_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_tod*/ - break; - -/**** - *REAL_TO_DT - */ - case function_real_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_dt*/ - break; - -/**** - *REAL_TO_STRING - */ - case function_real_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_string*/ - break; - -/**** - *REAL_TO_BYTE - */ - case function_real_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_byte*/ - break; - -/**** - *REAL_TO_WORD - */ - case function_real_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_word*/ - break; - -/**** - *REAL_TO_DWORD - */ - case function_real_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_dword*/ - break; - -/**** - *REAL_TO_LWORD - */ - case function_real_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_lword*/ - break; - -/**** - *LREAL_TO_BOOL - */ - case function_lreal_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_bool*/ - break; - -/**** - *LREAL_TO_SINT - */ - case function_lreal_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_sint*/ - break; - -/**** - *LREAL_TO_INT - */ - case function_lreal_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_int*/ - break; - -/**** - *LREAL_TO_DINT - */ - case function_lreal_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_dint*/ - break; - -/**** - *LREAL_TO_LINT - */ - case function_lreal_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_lint*/ - break; - -/**** - *LREAL_TO_USINT - */ - case function_lreal_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_usint*/ - break; - -/**** - *LREAL_TO_UINT - */ - case function_lreal_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_uint*/ - break; - -/**** - *LREAL_TO_UDINT - */ - case function_lreal_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_udint*/ - break; - -/**** - *LREAL_TO_ULINT - */ - case function_lreal_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_ulint*/ - break; - -/**** - *LREAL_TO_REAL - */ - case function_lreal_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_real*/ - break; - -/**** - *LREAL_TO_TIME - */ - case function_lreal_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_time*/ - break; - -/**** - *LREAL_TO_DATE - */ - case function_lreal_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_date*/ - break; - -/**** - *LREAL_TO_TOD - */ - case function_lreal_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_tod*/ - break; - -/**** - *LREAL_TO_DT - */ - case function_lreal_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_dt*/ - break; - -/**** - *LREAL_TO_STRING - */ - case function_lreal_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_string*/ - break; - -/**** - *LREAL_TO_BYTE - */ - case function_lreal_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_byte*/ - break; - -/**** - *LREAL_TO_WORD - */ - case function_lreal_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_word*/ - break; - -/**** - *LREAL_TO_DWORD - */ - case function_lreal_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_dword*/ - break; - -/**** - *LREAL_TO_LWORD - */ - case function_lreal_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_lword*/ - break; - -/**** - *TIME_TO_SINT - */ - case function_time_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_sint*/ - break; - -/**** - *TIME_TO_INT - */ - case function_time_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_int*/ - break; - -/**** - *TIME_TO_DINT - */ - case function_time_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_dint*/ - break; - -/**** - *TIME_TO_LINT - */ - case function_time_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_lint*/ - break; - -/**** - *TIME_TO_USINT - */ - case function_time_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_usint*/ - break; - -/**** - *TIME_TO_UINT - */ - case function_time_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_uint*/ - break; - -/**** - *TIME_TO_UDINT - */ - case function_time_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_udint*/ - break; - -/**** - *TIME_TO_ULINT - */ - case function_time_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_ulint*/ - break; - -/**** - *TIME_TO_REAL - */ - case function_time_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_real*/ - break; - -/**** - *TIME_TO_LREAL - */ - case function_time_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_lreal*/ - break; - -/**** - *TIME_TO_STRING - */ - case function_time_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_string*/ - break; - -/**** - *TIME_TO_BYTE - */ - case function_time_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_byte*/ - break; - -/**** - *TIME_TO_WORD - */ - case function_time_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_word*/ - break; - -/**** - *TIME_TO_DWORD - */ - case function_time_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_dword*/ - break; - -/**** - *TIME_TO_LWORD - */ - case function_time_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_lword*/ - break; - -/**** - *DATE_TO_SINT - */ - case function_date_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_sint*/ - break; - -/**** - *DATE_TO_INT - */ - case function_date_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_int*/ - break; - -/**** - *DATE_TO_DINT - */ - case function_date_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_dint*/ - break; - -/**** - *DATE_TO_LINT - */ - case function_date_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_lint*/ - break; - -/**** - *DATE_TO_USINT - */ - case function_date_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_usint*/ - break; - -/**** - *DATE_TO_UINT - */ - case function_date_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_uint*/ - break; - -/**** - *DATE_TO_UDINT - */ - case function_date_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_udint*/ - break; - -/**** - *DATE_TO_ULINT - */ - case function_date_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_ulint*/ - break; - -/**** - *DATE_TO_REAL - */ - case function_date_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_real*/ - break; - -/**** - *DATE_TO_LREAL - */ - case function_date_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_lreal*/ - break; - -/**** - *DATE_TO_STRING - */ - case function_date_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__date_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_string*/ - break; - -/**** - *DATE_TO_BYTE - */ - case function_date_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_byte*/ - break; - -/**** - *DATE_TO_WORD - */ - case function_date_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_word*/ - break; - -/**** - *DATE_TO_DWORD - */ - case function_date_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_dword*/ - break; - -/**** - *DATE_TO_LWORD - */ - case function_date_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_lword*/ - break; - -/**** - *TOD_TO_SINT - */ - case function_tod_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_sint*/ - break; - -/**** - *TOD_TO_INT - */ - case function_tod_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_int*/ - break; - -/**** - *TOD_TO_DINT - */ - case function_tod_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_dint*/ - break; - -/**** - *TOD_TO_LINT - */ - case function_tod_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_lint*/ - break; - -/**** - *TOD_TO_USINT - */ - case function_tod_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_usint*/ - break; - -/**** - *TOD_TO_UINT - */ - case function_tod_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_uint*/ - break; - -/**** - *TOD_TO_UDINT - */ - case function_tod_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_udint*/ - break; - -/**** - *TOD_TO_ULINT - */ - case function_tod_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_ulint*/ - break; - -/**** - *TOD_TO_REAL - */ - case function_tod_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_real*/ - break; - -/**** - *TOD_TO_LREAL - */ - case function_tod_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_lreal*/ - break; - -/**** - *TOD_TO_STRING - */ - case function_tod_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__tod_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_string*/ - break; - -/**** - *TOD_TO_BYTE - */ - case function_tod_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_byte*/ - break; - -/**** - *TOD_TO_WORD - */ - case function_tod_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_word*/ - break; - -/**** - *TOD_TO_DWORD - */ - case function_tod_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_dword*/ - break; - -/**** - *TOD_TO_LWORD - */ - case function_tod_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_lword*/ - break; - -/**** - *DT_TO_SINT - */ - case function_dt_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_sint*/ - break; - -/**** - *DT_TO_INT - */ - case function_dt_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_int*/ - break; - -/**** - *DT_TO_DINT - */ - case function_dt_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_dint*/ - break; - -/**** - *DT_TO_LINT - */ - case function_dt_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_lint*/ - break; - -/**** - *DT_TO_USINT - */ - case function_dt_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_usint*/ - break; - -/**** - *DT_TO_UINT - */ - case function_dt_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_uint*/ - break; - -/**** - *DT_TO_UDINT - */ - case function_dt_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_udint*/ - break; - -/**** - *DT_TO_ULINT - */ - case function_dt_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_ulint*/ - break; - -/**** - *DT_TO_REAL - */ - case function_dt_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_real*/ - break; - -/**** - *DT_TO_LREAL - */ - case function_dt_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_lreal*/ - break; - -/**** - *DT_TO_STRING - */ - case function_dt_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__dt_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_string*/ - break; - -/**** - *DT_TO_BYTE - */ - case function_dt_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_byte*/ - break; - -/**** - *DT_TO_WORD - */ - case function_dt_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_word*/ - break; - -/**** - *DT_TO_DWORD - */ - case function_dt_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_dword*/ - break; - -/**** - *DT_TO_LWORD - */ - case function_dt_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_lword*/ - break; - -/**** - *STRING_TO_BOOL - */ - case function_string_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_bool("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_bool*/ - break; - -/**** - *STRING_TO_SINT - */ - case function_string_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_sint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_sint*/ - break; - -/**** - *STRING_TO_INT - */ - case function_string_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_sint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_int*/ - break; - -/**** - *STRING_TO_DINT - */ - case function_string_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_sint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_dint*/ - break; - -/**** - *STRING_TO_LINT - */ - case function_string_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_sint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_lint*/ - break; - -/**** - *STRING_TO_USINT - */ - case function_string_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_usint*/ - break; - -/**** - *STRING_TO_UINT - */ - case function_string_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_uint*/ - break; - -/**** - *STRING_TO_UDINT - */ - case function_string_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_udint*/ - break; - -/**** - *STRING_TO_ULINT - */ - case function_string_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_ulint*/ - break; - -/**** - *STRING_TO_REAL - */ - case function_string_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_real*/ - break; - -/**** - *STRING_TO_LREAL - */ - case function_string_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_lreal*/ - break; - -/**** - *STRING_TO_TIME - */ - case function_string_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_time*/ - break; - -/**** - *STRING_TO_DATE - */ - case function_string_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_date*/ - break; - -/**** - *STRING_TO_TOD - */ - case function_string_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_tod*/ - break; - -/**** - *STRING_TO_DT - */ - case function_string_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_dt*/ - break; - -/**** - *STRING_TO_BYTE - */ - case function_string_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_bit("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_byte*/ - break; - -/**** - *STRING_TO_WORD - */ - case function_string_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_bit("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_word*/ - break; - -/**** - *STRING_TO_DWORD - */ - case function_string_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_bit("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_dword*/ - break; - -/**** - *STRING_TO_LWORD - */ - case function_string_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_bit("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_lword*/ - break; - -/**** - *BYTE_TO_BOOL - */ - case function_byte_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_bool*/ - break; - -/**** - *BYTE_TO_SINT - */ - case function_byte_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_sint*/ - break; - -/**** - *BYTE_TO_INT - */ - case function_byte_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_int*/ - break; - -/**** - *BYTE_TO_DINT - */ - case function_byte_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_dint*/ - break; - -/**** - *BYTE_TO_LINT - */ - case function_byte_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_lint*/ - break; - -/**** - *BYTE_TO_USINT - */ - case function_byte_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_usint*/ - break; - -/**** - *BYTE_TO_UINT - */ - case function_byte_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_uint*/ - break; - -/**** - *BYTE_TO_UDINT - */ - case function_byte_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_udint*/ - break; - -/**** - *BYTE_TO_ULINT - */ - case function_byte_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_ulint*/ - break; - -/**** - *BYTE_TO_REAL - */ - case function_byte_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_real*/ - break; - -/**** - *BYTE_TO_LREAL - */ - case function_byte_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_lreal*/ - break; - -/**** - *BYTE_TO_TIME - */ - case function_byte_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_time*/ - break; - -/**** - *BYTE_TO_DATE - */ - case function_byte_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_date*/ - break; - -/**** - *BYTE_TO_TOD - */ - case function_byte_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_tod*/ - break; - -/**** - *BYTE_TO_DT - */ - case function_byte_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_dt*/ - break; - -/**** - *BYTE_TO_STRING - */ - case function_byte_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bit_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_string*/ - break; - -/**** - *BYTE_TO_WORD - */ - case function_byte_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_word*/ - break; - -/**** - *BYTE_TO_DWORD - */ - case function_byte_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_dword*/ - break; - -/**** - *BYTE_TO_LWORD - */ - case function_byte_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_lword*/ - break; - -/**** - *WORD_TO_BOOL - */ - case function_word_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_bool*/ - break; - -/**** - *WORD_TO_SINT - */ - case function_word_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_sint*/ - break; - -/**** - *WORD_TO_INT - */ - case function_word_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_int*/ - break; - -/**** - *WORD_TO_DINT - */ - case function_word_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_dint*/ - break; - -/**** - *WORD_TO_LINT - */ - case function_word_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_lint*/ - break; - -/**** - *WORD_TO_USINT - */ - case function_word_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_usint*/ - break; - -/**** - *WORD_TO_UINT - */ - case function_word_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_uint*/ - break; - -/**** - *WORD_TO_UDINT - */ - case function_word_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_udint*/ - break; - -/**** - *WORD_TO_ULINT - */ - case function_word_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_ulint*/ - break; - -/**** - *WORD_TO_REAL - */ - case function_word_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_real*/ - break; - -/**** - *WORD_TO_LREAL - */ - case function_word_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_lreal*/ - break; - -/**** - *WORD_TO_TIME - */ - case function_word_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_time*/ - break; - -/**** - *WORD_TO_DATE - */ - case function_word_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_date*/ - break; - -/**** - *WORD_TO_TOD - */ - case function_word_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_tod*/ - break; - -/**** - *WORD_TO_DT - */ - case function_word_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_dt*/ - break; - -/**** - *WORD_TO_STRING - */ - case function_word_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bit_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_string*/ - break; - -/**** - *WORD_TO_BYTE - */ - case function_word_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_byte*/ - break; - -/**** - *WORD_TO_DWORD - */ - case function_word_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_dword*/ - break; - -/**** - *WORD_TO_LWORD - */ - case function_word_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_lword*/ - break; - -/**** - *DWORD_TO_BOOL - */ - case function_dword_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_bool*/ - break; - -/**** - *DWORD_TO_SINT - */ - case function_dword_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_sint*/ - break; - -/**** - *DWORD_TO_INT - */ - case function_dword_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_int*/ - break; - -/**** - *DWORD_TO_DINT - */ - case function_dword_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_dint*/ - break; - -/**** - *DWORD_TO_LINT - */ - case function_dword_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_lint*/ - break; - -/**** - *DWORD_TO_USINT - */ - case function_dword_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_usint*/ - break; - -/**** - *DWORD_TO_UINT - */ - case function_dword_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_uint*/ - break; - -/**** - *DWORD_TO_UDINT - */ - case function_dword_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_udint*/ - break; - -/**** - *DWORD_TO_ULINT - */ - case function_dword_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_ulint*/ - break; - -/**** - *DWORD_TO_REAL - */ - case function_dword_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_real*/ - break; - -/**** - *DWORD_TO_LREAL - */ - case function_dword_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_lreal*/ - break; - -/**** - *DWORD_TO_TIME - */ - case function_dword_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_time*/ - break; - -/**** - *DWORD_TO_DATE - */ - case function_dword_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_date*/ - break; - -/**** - *DWORD_TO_TOD - */ - case function_dword_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_tod*/ - break; - -/**** - *DWORD_TO_DT - */ - case function_dword_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_dt*/ - break; - -/**** - *DWORD_TO_STRING - */ - case function_dword_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bit_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_string*/ - break; - -/**** - *DWORD_TO_BYTE - */ - case function_dword_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_byte*/ - break; - -/**** - *DWORD_TO_WORD - */ - case function_dword_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_word*/ - break; - -/**** - *DWORD_TO_LWORD - */ - case function_dword_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_lword*/ - break; - -/**** - *LWORD_TO_BOOL - */ - case function_lword_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_bool*/ - break; - -/**** - *LWORD_TO_SINT - */ - case function_lword_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_sint*/ - break; - -/**** - *LWORD_TO_INT - */ - case function_lword_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_int*/ - break; - -/**** - *LWORD_TO_DINT - */ - case function_lword_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_dint*/ - break; - -/**** - *LWORD_TO_LINT - */ - case function_lword_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_lint*/ - break; - -/**** - *LWORD_TO_USINT - */ - case function_lword_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_usint*/ - break; - -/**** - *LWORD_TO_UINT - */ - case function_lword_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_uint*/ - break; - -/**** - *LWORD_TO_UDINT - */ - case function_lword_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_udint*/ - break; - -/**** - *LWORD_TO_ULINT - */ - case function_lword_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_ulint*/ - break; - -/**** - *LWORD_TO_REAL - */ - case function_lword_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_real*/ - break; - -/**** - *LWORD_TO_LREAL - */ - case function_lword_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_lreal*/ - break; - -/**** - *LWORD_TO_TIME - */ - case function_lword_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_time*/ - break; - -/**** - *LWORD_TO_DATE - */ - case function_lword_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_date*/ - break; - -/**** - *LWORD_TO_TOD - */ - case function_lword_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_tod*/ - break; - -/**** - *LWORD_TO_DT - */ - case function_lword_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_dt*/ - break; - -/**** - *LWORD_TO_STRING - */ - case function_lword_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bit_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_string*/ - break; - -/**** - *LWORD_TO_BYTE - */ - case function_lword_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_byte*/ - break; - -/**** - *LWORD_TO_WORD - */ - case function_lword_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_word*/ - break; - -/**** - *LWORD_TO_DWORD - */ - case function_lword_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_dword*/ - break; - -/**** - *TRUNC - */ - case function_trunc : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - s4o.print("(int)"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_trunc*/ - break; - -/**** - *BCD_TO_USINT - */ - case function_bcd_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bcd_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bcd_to_usint*/ - break; - -/**** - *BCD_TO_UINT - */ - case function_bcd_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bcd_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bcd_to_uint*/ - break; - -/**** - *BCD_TO_UDINT - */ - case function_bcd_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bcd_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bcd_to_udint*/ - break; - -/**** - *BCD_TO_ULINT - */ - case function_bcd_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bcd_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bcd_to_ulint*/ - break; - -/**** - *USINT_TO_BCD - */ - case function_usint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_bcd("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_bcd*/ - break; - -/**** - *UINT_TO_BCD - */ - case function_uint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_bcd("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_bcd*/ - break; - -/**** - *UDINT_TO_BCD - */ - case function_udint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_bcd("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_bcd*/ - break; - -/**** - *ULINT_TO_BCD - */ - case function_ulint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_bcd("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_bcd*/ - break; - -/**** - *DATE_AND_TIME_TO_TIME_OF_DAY - */ - case function_date_and_time_to_time_of_day : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("__date_and_time_to_time_of_day("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_and_time_to_time_of_day*/ - break; - -/**** - *DATE_AND_TIME_TO_DATE - */ - case function_date_and_time_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("__date_and_time_to_date("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_and_time_to_date*/ - break; - -/**** - *ABS - */ - case function_abs : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("__abs_"); - IN_type_symbol->accept(*this); - s4o.print("("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_abs*/ - break; - -/**** - *SQRT - */ - case function_sqrt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("sqrt("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sqrt*/ - break; - -/**** - *LN - */ - case function_ln : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("ln("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ln*/ - break; - -/**** - *LOG - */ - case function_log : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("log("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_log*/ - break; - -/**** - *EXP - */ - case function_exp : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("exp("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_exp*/ - break; - -/**** - *SIN - */ - case function_sin : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("sin("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sin*/ - break; - -/**** - *COS - */ - case function_cos : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("cos("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_cos*/ - break; - -/**** - *TAN - */ - case function_tan : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("tan("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tan*/ - break; - -/**** - *ASIN - */ - case function_asin : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("asin("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_asin*/ - break; - -/**** - *ACOS - */ - case function_acos : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("acos("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_acos*/ - break; - -/**** - *ATAN - */ - case function_atan : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("atan("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_atan*/ - break; - -/**** - *ADD - */ - case function_add : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("+\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print("+\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("__time_add("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("__time_add("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_add("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_add*/ - break; - -/**** - *MUL - */ - case function_mul : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("*\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print("*\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_mul("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mul*/ - break; - -/**** - *SUB - */ - case function_sub : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("-\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_sub("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_sub("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("__time_sub("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_sub("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("__time_sub("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_sub("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_sub*/ - break; - -/**** - *DIV - */ - case function_div : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("/\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_div("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_div*/ - break; - -/**** - *MOD - */ - case function_mod : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("%\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mod*/ - break; - -/**** - *EXPT - */ - case function_expt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.print("pow("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_expt*/ - break; - -/**** - *MOVE - */ - case function_move : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_move*/ - break; - -/**** - *SHL - */ - case function_shl : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_binary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - IN_param_value->accept(*this); - s4o.print("<<"); - N_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_shl*/ - break; - -/**** - *SHR - */ - case function_shr : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_binary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - IN_param_value->accept(*this); - s4o.print(">>"); - N_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_shr*/ - break; - -/**** - *ROR - */ - case function_ror : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_nbinary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("__ror_"); - IN_type_symbol->accept(*this); - s4o.print("("); - IN_param_value->accept(*this); - s4o.print(", "); - N_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_ror*/ - break; - -/**** - *ROL - */ - case function_rol : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_nbinary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("__rol_"); - IN_type_symbol->accept(*this); - s4o.print("("); - IN_param_value->accept(*this); - s4o.print(", "); - N_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_rol*/ - break; - -/**** - *AND - */ - case function_and : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_binary_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_binary_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("("); - if (search_expression_type->is_bool_type(last_type_symbol)) - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("&\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print("&\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - if (search_expression_type->is_bool_type(last_type_symbol)) { - s4o.print("&1"); - s4o.print(")"); - } - s4o.print(""); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_and*/ - break; - -/**** - *OR - */ - case function_or : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_binary_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_binary_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("("); - if (search_expression_type->is_bool_type(last_type_symbol)) - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("|\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print("|\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - if (search_expression_type->is_bool_type(last_type_symbol)) { - s4o.print("&1"); - s4o.print(")"); - } - s4o.print(""); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_or*/ - break; - -/**** - *XOR - */ - case function_xor : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_binary_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_binary_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("("); - if (search_expression_type->is_bool_type(last_type_symbol)) - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("^\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print("^\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - if (search_expression_type->is_bool_type(last_type_symbol)) { - s4o.print("&1"); - s4o.print(")"); - } - s4o.print(""); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_xor*/ - break; - -/**** - *NOT - */ - case function_not : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_binary_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("~"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_not*/ - break; - -/**** - *SEL - */ - case function_sel : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *G_param_value = &this->default_variable_name; - - symbol_c *G_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN0"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN0_param_value == NULL) - IN0_param_value = function_call_param_iterator.next(); - symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; - - - { - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - G_param_value->accept(*this); - s4o.print(" ? "); - IN1_param_value->accept(*this); - s4o.print(" : "); - IN0_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_sel*/ - break; - -/**** - *MAX - */ - case function_max : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("__max_"); - return_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_max*/ - break; - -/**** - *MIN - */ - case function_min : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("__min_"); - return_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_min*/ - break; - -/**** - *LIMIT - */ - case function_limit : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *MN_param_value = &this->default_variable_name; - - symbol_c *MN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - - { - - { - identifier_c param_name("MX"); - /* Get the value from a foo( = ) style call */ - symbol_c *MX_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (MX_param_value == NULL) - MX_param_value = function_call_param_iterator.next(); - symbol_c *MX_type_symbol = search_expression_type->get_type(MX_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(MX_type_symbol, last_type_symbol) ? search_expression_type->common_type(MX_type_symbol, last_type_symbol) : MX_type_symbol ; - - - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("__limit_"); - IN_type_symbol->accept(*this); - s4o.print("("); - MN_param_value->accept(*this); - s4o.print(", "); - IN_param_value->accept(*this); - s4o.print(", "); - MX_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_limit*/ - break; - -/**** - *MUX - */ - case function_mux : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *K_param_value = &this->default_variable_name; - - symbol_c *K_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_integer_type(K_type_symbol)) - { - - { - identifier_c param_name("IN0"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN0_param_value == NULL) - IN0_param_value = function_call_param_iterator.next(); - symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; - - - { - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("__mux_"); - return_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - K_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN0_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - - int base_num = 2; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mux*/ - break; - -/**** - *GT - */ - case function_gt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.indent_right(); - s4o.print("__gt_"); - last_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_gt*/ - break; - -/**** - *GE - */ - case function_ge : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.indent_right(); - s4o.print("__ge_"); - last_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_ge*/ - break; - -/**** - *EQ - */ - case function_eq : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.indent_right(); - s4o.print("__eq_"); - last_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_eq*/ - break; - -/**** - *LT - */ - case function_lt : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.indent_right(); - s4o.print("__lt_"); - last_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_lt*/ - break; - -/**** - *LE - */ - case function_le : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.indent_right(); - s4o.print("__le_"); - last_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_le*/ - break; - -/**** - *NE - */ - case function_ne : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.indent_right(); - s4o.print("__ne_"); - last_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_ne*/ - break; - -/**** - *LEN - */ - case function_len : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("__len("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_len*/ - break; - -/**** - *LEFT - */ - case function_left : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("__left("); - IN_param_value->accept(*this); - s4o.print(", "); - L_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_left*/ - break; - -/**** - *RIGHT - */ - case function_right : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("__right("); - IN_param_value->accept(*this); - s4o.print(", "); - L_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_right*/ - break; - -/**** - *MID - */ - case function_mid : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("__mid("); - IN_param_value->accept(*this); - s4o.print(", "); - L_param_value->accept(*this); - s4o.print(", "); - P_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mid*/ - break; - -/**** - *CONCAT - */ - case function_concat : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("__time_add("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.indent_right(); - s4o.print("__concat("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_concat*/ - break; - -/**** - *INSERT - */ - case function_insert : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("__insert("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(", "); - P_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_insert*/ - break; - -/**** - *DELETE - */ - case function_delete : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = &this->default_variable_name; - - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("__delete("); - IN_param_value->accept(*this); - s4o.print(", "); - L_param_value->accept(*this); - s4o.print(", "); - P_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_delete*/ - break; - -/**** - *REPLACE - */ - case function_replace : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("__replace("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(", "); - L_param_value->accept(*this); - s4o.print(", "); - P_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_replace*/ - break; - -/**** - *FIND - */ - case function_find : - { - symbol_c *last_type_symbol = NULL; - - { - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = &this->default_variable_name; - - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("__find("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_find*/ - break; - - case function_none : - ERROR; -} -return NULL; diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/plc.h --- a/stage4/generate_cc/plc.h Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,85 +0,0 @@ -/* - * (c) 2000 Jiri Baum - * Mario de Sousa - * - * 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. - */ - - -#ifndef __PLC_H -#define __PLC_H - -#include /* required for declaration of FILE */ - -#ifdef __cplusplus -extern "C" { -#endif - - -#include "types.h" -#include "log/log.h" -#include "conffile/conffile.h" -#include "cmm/cmm.h" -#include "gmm/gmm.h" -#include "synch/synch.h" -#include "period/period.h" -#include "state/state.h" -#include "rt/rt.h" - - -#define PLC_PT_NAME_MAX_LEN CMM_NAME_MAX_LEN - -/*** GENERAL ***/ -int plc_init(char const *module_name, int argc, char **argv); -int plc_done(void); - -/*** SYNCHING ***/ -int plc_scan_beg(void); -int plc_scan_end(void); - -/* memory must be de-allocated with free() */ -const char *plc_module_name(void); - -/* - * UTIL functions; - */ -int plc_print_usage(FILE *output); -/* prints the command line arguments the plc_init() function accepts */ - -/* not to be used by general plc modules. This function is used by the - * plc_shutdown() function. - */ -int plc_init_try(char const *module_name, int argc, char **argv); - - -/* plc command line options leader */ -#define CLO_LEADER "--PLC" - -/* plc command line options */ -#define CLO_plc_id CLO_LEADER "plc_id=" -#define CLO_loc_local CLO_LEADER "local" -#define CLO_loc_isolate CLO_LEADER "isolate" -#define CLO_loc_shared CLO_LEADER "shared" -#define CLO_privmap_key CLO_LEADER "local_map_key=" -#define CLO_log_level CLO_LEADER "debug=" -#define CLO_log_file CLO_LEADER "logfile=" -#define CLO_config_file CLO_LEADER "conf=" -#define CLO_module_name CLO_LEADER "module=" -#define CLO_force_init CLO_LEADER "force-init" - - -#ifdef __cplusplus -} -#endif - -#endif /* __PLC_H */ diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/search_base_type.cc --- a/stage4/generate_cc/search_base_type.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,215 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* Determine the data type on which another data type is based on. - * If a new default initial value is given, we DO NOT consider it a - * new base class, and continue looking further! - * - * E.g. TYPE new_int_t : INT; END_TYPE; - * TYPE new_int2_t : INT = 2; END_TYPE; - * TYPE new_subr_t : INT (4..5); END_TYPE; - * - * new_int_t is really an INT!! - * new_int2_t is also really an INT!! - * new_subr_t is also really an INT!! - */ -class search_base_type_c: public null_visitor_c { - private: - symbol_c *current_type_name; - - public: - search_base_type_c(void) {current_type_name = NULL;} - - public: - void *visit(identifier_c *type_name) { - this->current_type_name = type_name; - /* look up the type declaration... */ - symbol_c *type_decl = type_symtable.find_value(type_name); - if (type_decl == type_symtable.end_value()) - /* Type declaration not found!! */ - ERROR; - - return type_decl->accept(*this); - } - -/***********************************/ -/* B 1.3.1 - Elementary Data Types */ -/***********************************/ - void *visit(time_type_name_c *symbol) {return (void *)symbol;} - void *visit(bool_type_name_c *symbol) {return (void *)symbol;} - void *visit(sint_type_name_c *symbol) {return (void *)symbol;} - void *visit(int_type_name_c *symbol) {return (void *)symbol;} - void *visit(dint_type_name_c *symbol) {return (void *)symbol;} - void *visit(lint_type_name_c *symbol) {return (void *)symbol;} - void *visit(usint_type_name_c *symbol) {return (void *)symbol;} - void *visit(uint_type_name_c *symbol) {return (void *)symbol;} - void *visit(udint_type_name_c *symbol) {return (void *)symbol;} - void *visit(ulint_type_name_c *symbol) {return (void *)symbol;} - void *visit(real_type_name_c *symbol) {return (void *)symbol;} - void *visit(lreal_type_name_c *symbol) {return (void *)symbol;} - void *visit(date_type_name_c *symbol) {return (void *)symbol;} - void *visit(tod_type_name_c *symbol) {return (void *)symbol;} - void *visit(dt_type_name_c *symbol) {return (void *)symbol;} - void *visit(byte_type_name_c *symbol) {return (void *)symbol;} - void *visit(word_type_name_c *symbol) {return (void *)symbol;} - void *visit(dword_type_name_c *symbol) {return (void *)symbol;} - void *visit(lword_type_name_c *symbol) {return (void *)symbol;} - void *visit(string_type_name_c *symbol) {return (void *)symbol;} - void *visit(wstring_type_name_c *symbol) {return (void *)symbol;} - void *visit(constant_int_type_name_c *symbol) {return (void *)symbol;} - void *visit(constant_real_type_name_c *symbol) {return (void *)symbol;} - -/********************************/ -/* B 1.3.3 - Derived data types */ -/********************************/ -/* simple_type_name ':' simple_spec_init */ - void *visit(simple_type_declaration_c *symbol) { - return symbol->simple_spec_init->accept(*this); - } -/* simple_specification ASSIGN constant */ - void *visit(simple_spec_init_c *symbol) { - return symbol->simple_specification->accept(*this); - } - -/* subrange_type_name ':' subrange_spec_init */ - void *visit(subrange_type_declaration_c *symbol) { - return symbol->subrange_spec_init->accept(*this); - } - -/* subrange_specification ASSIGN signed_integer */ - void *visit(subrange_spec_init_c *symbol) { - return symbol->subrange_specification->accept(*this); - } - -/* integer_type_name '(' subrange')' */ - void *visit(subrange_specification_c *symbol) { - return symbol->integer_type_name->accept(*this); - } - -/* signed_integer DOTDOT signed_integer */ - void *visit(subrange_c *symbol) {ERROR; return NULL;} /* should never get called... */ - -/* enumerated_type_name ':' enumerated_spec_init */ - void *visit(enumerated_type_declaration_c *symbol) { - this->current_type_name = symbol->enumerated_type_name; - return symbol->enumerated_spec_init->accept(*this); - } - -/* enumerated_specification ASSIGN enumerated_value */ - void *visit(enumerated_spec_init_c *symbol) { - return symbol->enumerated_specification->accept(*this); - } - -/* helper symbol for enumerated_specification->enumerated_spec_init */ -/* enumerated_value_list ',' enumerated_value */ - void *visit(enumerated_value_list_c *symbol) { - if (NULL == this->current_type_name) ERROR; - return (void *)this->current_type_name; - } - -/* enumerated_type_name '#' identifier */ -// SYM_REF2(enumerated_value_c, type, value) - void *visit(enumerated_value_c *symbol) {ERROR; return NULL;} /* should never get called... */ - -/* identifier ':' array_spec_init */ - void *visit(array_type_declaration_c *symbol) { - this->current_type_name = symbol->identifier; - return symbol->array_spec_init->accept(*this); - } - -/* array_specification [ASSIGN array_initialization} */ -/* array_initialization may be NULL ! */ - void *visit(array_spec_init_c *symbol) { - return symbol->array_specification->accept(*this); - } - -/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */ - void *visit(array_specification_c *symbol) { - if (NULL == this->current_type_name) ERROR; - return (void *)this->current_type_name; - } - -/* helper symbol for array_specification */ -/* array_subrange_list ',' subrange */ - void *visit(array_subrange_list_c *symbol) {ERROR; return NULL;} /* should never get called... */ - -/* array_initialization: '[' array_initial_elements_list ']' */ -/* helper symbol for array_initialization */ -/* array_initial_elements_list ',' array_initial_elements */ - void *visit(array_initial_elements_list_c *symbol) {ERROR; return NULL;} /* should never get called... */ - -/* integer '(' [array_initial_element] ')' */ -/* array_initial_element may be NULL ! */ - void *visit(array_initial_elements_c *symbol) {ERROR; return NULL;} /* should never get called... */ - -/* structure_type_name ':' structure_specification */ - /* NOTE: structure_specification will point to either a - * initialized_structure_c - * OR A - * structure_element_declaration_list_c - */ - void *visit(structure_type_declaration_c *symbol) { - this->current_type_name = symbol->structure_type_name; - return symbol->structure_specification->accept(*this); - } - -/* structure_type_name ASSIGN structure_initialization */ -/* structure_initialization may be NULL ! */ - void *visit(initialized_structure_c *symbol) { - return symbol->structure_type_name->accept(*this); - } - -/* helper symbol for structure_declaration */ -/* structure_declaration: STRUCT structure_element_declaration_list END_STRUCT */ -/* structure_element_declaration_list structure_element_declaration ';' */ - void *visit(structure_element_declaration_list_c *symbol) { - if (NULL == this->current_type_name) ERROR; - return (void *)this->current_type_name; - } - -/* structure_element_name ':' *_spec_init */ - void *visit(structure_element_declaration_c *symbol) {ERROR; return NULL;} /* should never get called... */ - -/* helper symbol for structure_initialization */ -/* structure_initialization: '(' structure_element_initialization_list ')' */ -/* structure_element_initialization_list ',' structure_element_initialization */ - void *visit(structure_element_initialization_list_c *symbol) {ERROR; return NULL;} /* should never get called... */ - -/* structure_element_name ASSIGN value */ - void *visit(structure_element_initialization_c *symbol) {ERROR; return NULL;} /* should never get called... */ - -/* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ -/* -SYM_REF4(string_type_declaration_c, string_type_name, - elementary_string_type_name, - string_type_declaration_size, - string_type_declaration_init) // may be == NULL! -*/ - void *visit(string_type_declaration_c *symbol) {return symbol;} -}; - - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/search_constant_type.cc --- a/stage4/generate_cc/search_constant_type.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,161 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - - -/* Determine the data type of a specific constant or variable. - * A reference to the relevant type definition is returned. - * - * For example: - * 22 -> returns reference to a int_type_name_c object. - * 22.2 -> returns reference to a real_type_name_c object. - * LREAL#22.2 -> returns reference to a lreal_type_name_c object. - * etc... - */ -class search_constant_type_c: public search_visitor_c { - - public: -/**********************/ -/* B.1.3 - Data types */ -/**********************/ -/***********************************/ -/* B 1.3.1 - Elementary Data Types */ -/***********************************/ - static real_type_name_c real_type_name; - static sint_type_name_c sint_type_name; - static lint_type_name_c lint_type_name; - static dint_type_name_c dint_type_name; - static date_type_name_c date_type_name; - static dword_type_name_c dword_type_name; - static dt_type_name_c dt_type_name; - static tod_type_name_c tod_type_name; - static udint_type_name_c udint_type_name; - static word_type_name_c word_type_name; - static wstring_type_name_c wstring_type_name; - static string_type_name_c string_type_name; - static lword_type_name_c lword_type_name; - static uint_type_name_c uint_type_name; - static lreal_type_name_c lreal_type_name; - static byte_type_name_c byte_type_name; - static usint_type_name_c usint_type_name; - static ulint_type_name_c ulint_type_name; - static bool_type_name_c bool_type_name; - static time_type_name_c time_type_name; - static int_type_name_c int_type_name; - - static constant_real_type_name_c constant_real_type_name; - static constant_int_type_name_c constant_int_type_name; - - public: - symbol_c *get_type(symbol_c *constant) { - return (symbol_c *)constant->accept(*this); - } - - public: -/*********************/ -/* B 1.2 - Constants */ -/*********************/ - -/******************************/ -/* B 1.2.1 - Numeric Literals */ -/******************************/ - void *visit(real_c *symbol) {return (void *)&constant_real_type_name;} - void *visit(integer_c *symbol) {return (void *)&constant_int_type_name;} - void *visit(binary_integer_c *symbol) {return (void *)&constant_int_type_name;} - void *visit(octal_integer_c *symbol) {return (void *)&constant_int_type_name;} - void *visit(hex_integer_c *symbol) {return (void *)&constant_int_type_name;} - - void *visit(numeric_literal_c *symbol) - {return (void *)((symbol->type!=NULL)?symbol->type:symbol->value->accept(*this));} - void *visit(integer_literal_c *symbol) - {return (void *)((symbol->type!=NULL)?symbol->type:symbol->value->accept(*this));} - void *visit(real_literal_c *symbol) - {return (void *)((symbol->type!=NULL)?symbol->type:symbol->value->accept(*this));} - void *visit(bit_string_literal_c *symbol) - {return (void *)((symbol->type!=NULL)?symbol->type:symbol->value->accept(*this));} - void *visit(boolean_literal_c *symbol) - {return (void *)((symbol->type!=NULL)?symbol->type:symbol->value->accept(*this));} - -/*******************************/ -/* B.1.2.2 Character Strings */ -/*******************************/ - void *visit(double_byte_character_string_c *symbol) {return (void *)&wstring_type_name;} - void *visit(single_byte_character_string_c *symbol) {return (void *)&string_type_name;} - -/***************************/ -/* B 1.2.3 - Time Literals */ -/***************************/ -/************************/ -/* B 1.2.3.1 - Duration */ -/************************/ - void *visit(neg_time_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ - void *visit(duration_c *symbol) {return (void *)&time_type_name;} - void *visit(fixed_point_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ - void *visit(days_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ - void *visit(hours_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ - void *visit(minutes_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ - void *visit(seconds_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ - void *visit(milliseconds_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ - -/************************************/ -/* B 1.2.3.2 - Time of day and Date */ -/************************************/ - void *visit(time_of_day_c *symbol) {return (void *)&tod_type_name;} - void *visit(daytime_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ - void *visit(date_c *symbol) {return (void *)&date_type_name;} - void *visit(date_literal_c *symbol) {ERROR; return NULL;} /* this member function should never be called. */ - void *visit(date_and_time_c *symbol) {return (void *)&dt_type_name;} -}; - - -real_type_name_c search_constant_type_c::real_type_name; -sint_type_name_c search_constant_type_c::sint_type_name; -lint_type_name_c search_constant_type_c::lint_type_name; -dint_type_name_c search_constant_type_c::dint_type_name; -date_type_name_c search_constant_type_c::date_type_name; -dword_type_name_c search_constant_type_c::dword_type_name; -dt_type_name_c search_constant_type_c::dt_type_name; -tod_type_name_c search_constant_type_c::tod_type_name; -udint_type_name_c search_constant_type_c::udint_type_name; -word_type_name_c search_constant_type_c::word_type_name; -wstring_type_name_c search_constant_type_c::wstring_type_name; -string_type_name_c search_constant_type_c::string_type_name; -lword_type_name_c search_constant_type_c::lword_type_name; -uint_type_name_c search_constant_type_c::uint_type_name; -lreal_type_name_c search_constant_type_c::lreal_type_name; -byte_type_name_c search_constant_type_c::byte_type_name; -usint_type_name_c search_constant_type_c::usint_type_name; -ulint_type_name_c search_constant_type_c::ulint_type_name; -bool_type_name_c search_constant_type_c::bool_type_name; -time_type_name_c search_constant_type_c::time_type_name; -int_type_name_c search_constant_type_c::int_type_name; - -constant_real_type_name_c search_constant_type_c::constant_real_type_name; -constant_int_type_name_c search_constant_type_c::constant_int_type_name; - - - - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/search_expression_type.cc --- a/stage4/generate_cc/search_expression_type.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,494 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* Determine the data type of an ST expression. - * A reference to the relevant type definition is returned. - * - * For example: - * 2 + 3 -> returns reference to a int_type_name_c object. - * 22.2 - 5 -> returns reference to a real_type_name_c object. - * etc... - */ - -#include "function_type_decl.h" -#include "get_function_type_decl.c" - -#if 0 -typedef enum {function_add, - function_sub, - function_and, - function_or, - function_sqrt, - function_none} function_type_t; - - -function_type_t get_function_type(identifier_c *function_name) { - if (!strcasecmp(function_name->value, "ADD")) - return function_add; - else if (!strcasecmp(function_name->value, "SUB")) - return function_sub; - else if (!strcasecmp(function_name->value, "AND")) - return function_and; - else if (!strcasecmp(function_name->value, "OR")) - return function_or; - else if (!strcasecmp(function_name->value, "SQRT")) - return function_sqrt; - else return function_none; -} -#endif - - -symbol_c *generate_param_name(const char *name) { - symbol_c *param_name = new identifier_c(name); - return param_name; -} - - -symbol_c *generate_param_name(const char *format, int number) { - char name[10]; - sprintf(name, format, number); - symbol_c *param_name = new identifier_c(name); - return param_name; -} - - -class search_expression_type_c: public search_constant_type_c { - private: - search_varfb_instance_type_c *search_varfb_instance_type; - search_base_type_c search_base_type; - - public: - search_expression_type_c(symbol_c *search_scope) { - search_varfb_instance_type = new search_varfb_instance_type_c(search_scope); - } - - virtual ~search_expression_type_c(void) { - delete search_varfb_instance_type; - } - - /* A helper function... */ - bool is_bool_type(symbol_c *type_symbol) { - return (typeid(*type_symbol) == typeid(bool_type_name_c)); - } - - /* A helper function... */ - bool is_time_type(symbol_c *type_symbol) { - if (typeid(*type_symbol) == typeid(time_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(date_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(tod_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(dt_type_name_c)) {return true;} - return false; - } - - /* A helper function... */ - bool is_integer_type(symbol_c *type_symbol) { - if (typeid(*type_symbol) == typeid(sint_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(int_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(dint_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(lint_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(usint_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(uint_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(udint_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(ulint_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(constant_int_type_name_c)) {return true;} - return false; - } - - bool is_real_type(symbol_c *type_symbol) { - if (typeid(*type_symbol) == typeid(real_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(lreal_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(constant_real_type_name_c)) {return true;} - return false; - } - - bool is_num_type(symbol_c *type_symbol) { - return is_real_type(type_symbol) || is_integer_type(type_symbol); - } - - bool is_nbinary_type(symbol_c *type_symbol) { - if (typeid(*type_symbol) == typeid(byte_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(word_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(dword_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(lword_type_name_c)) {return true;} - if (typeid(*type_symbol) == typeid(constant_int_type_name_c)) {return true;} - return false; - } - - bool is_binary_type(symbol_c *type_symbol) { - if (typeid(*type_symbol) == typeid(bool_type_name_c)) {return true;} - return is_nbinary_type(type_symbol); - } - - bool is_same_type(symbol_c *first_type, symbol_c *second_type) { - if (typeid(*first_type) == typeid(*second_type)) {return true;} - if (is_integer_type(first_type) && (typeid(*second_type) == typeid(constant_int_type_name_c))) {return true;} - if ((typeid(*first_type) == typeid(constant_int_type_name_c) && is_integer_type(second_type))) {return true;} - if (is_binary_type(first_type) && (typeid(*second_type) == typeid(constant_int_type_name_c))) {return true;} - if ((typeid(*first_type) == typeid(constant_int_type_name_c) && is_binary_type(second_type))) {return true;} - if (is_real_type(first_type) && (typeid(*second_type) == typeid(constant_real_type_name_c))) {return true;} - if ((typeid(*first_type) == typeid(constant_real_type_name_c) && is_real_type(second_type))) {return true;} - return false; - } - - symbol_c* common_type(symbol_c *first_type, symbol_c *second_type) { - if (typeid(*first_type) == typeid(*second_type)) {return first_type;} - if (is_integer_type(first_type) && (typeid(*second_type) == typeid(constant_int_type_name_c))) {return first_type;} - if ((typeid(*first_type) == typeid(constant_int_type_name_c) && is_integer_type(second_type))) {return second_type;} - if (is_binary_type(first_type) && (typeid(*second_type) == typeid(constant_int_type_name_c))) {return first_type;} - if ((typeid(*first_type) == typeid(constant_int_type_name_c) && is_binary_type(second_type))) {return second_type;} - if (is_real_type(first_type) && (typeid(*second_type) == typeid(constant_real_type_name_c))) {return first_type;} - if ((typeid(*first_type) == typeid(constant_real_type_name_c) && is_real_type(second_type))) {return second_type;} - return NULL; - } - -#include "search_type_code.c" - -#if 0 - void *compute_standard_function_st(function_invocation_c *symbol) { - symbol_c *current_type = NULL; - symbol_c *return_type = NULL; - - function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name); - function_call_param_iterator_c function_call_param_iterator(symbol); - search_expression_type_c* search_expression_type = this; - - for(int current_param = 0; current_param < ((list_c *)symbol->parameter_assignment_list)->n; current_param++) { - symbol_c *param_name = NULL; - switch (current_function_type) { - case function_add: - case function_and: - case function_or: - param_name = generate_param_name("IN%d", current_param + 1); - break; - case function_sub: - if (current_param < 2) - param_name = generate_param_name("IN%d", current_param + 1); - else ERROR; - break; - default: ERROR; - } - - /* Get the value from a foo( = ) style call */ - symbol_c *param_value = function_call_param_iterator.search(param_name); - delete param_name; - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - - if (param_value == NULL) ERROR; - - symbol_c *param_type = (symbol_c *)param_value->accept(*this); - - switch (current_function_type) { - case function_add: - if (current_param == 0) - current_type = param_type; - else if (current_param == 1) { - if ((is_integer_type(current_type) && is_same_type(current_type, param_type)) || - (is_real_type(current_type) && is_same_type(current_type, param_type))) { - current_type = common_type(current_type, param_type); - return_type = current_type; - } - else if (is_time_type(current_type)) { - if ((typeid(*current_type) == typeid(time_type_name_c)) && (typeid(*param_type) == typeid(time_type_name_c))) {return_type = (symbol_c *)&time_type_name;} - else if (typeid(*current_type) == typeid(tod_type_name_c) && typeid(*param_type) == typeid(time_type_name_c)) {return_type = (symbol_c *)&tod_type_name;} - else if (typeid(*current_type) == typeid(dt_type_name_c) && typeid(*param_type) == typeid(time_type_name_c)) {return_type = (symbol_c *)&dt_type_name;} - else ERROR; - } - else ERROR; - } - else if (!is_time_type(current_type) && is_same_type(current_type, param_type)) { - current_type = common_type(current_type, param_type); - return_type = current_type; - } - else ERROR; - break; - case function_sub: - if (current_param == 0) - current_type = param_type; - else if (current_param == 1) { - if ((is_integer_type(current_type) && is_same_type(current_type, param_type)) || - (is_real_type(current_type) && is_same_type(current_type, param_type))) - return_type = common_type(current_type, param_type); - else if (is_time_type(current_type)) { - if (typeid(*current_type) == typeid(time_type_name_c) && typeid(*param_type) == typeid(time_type_name_c)) {return_type = (symbol_c *)&time_type_name;} - else if (typeid(*current_type) == typeid(date_type_name_c) && typeid(*param_type) == typeid(date_type_name_c)) {return_type = (symbol_c *)&time_type_name;} - else if (typeid(*current_type) == typeid(tod_type_name_c) && typeid(*param_type) == typeid(time_type_name_c)) {return_type = (symbol_c *)&tod_type_name;} - else if (typeid(*current_type) == typeid(tod_type_name_c) && typeid(*param_type) == typeid(tod_type_name_c)) {return_type = (symbol_c *)&time_type_name;} - else if (typeid(*current_type) == typeid(dt_type_name_c) && typeid(*param_type) == typeid(time_type_name_c)) {return_type = (symbol_c *)&dt_type_name;} - else if (typeid(*current_type) == typeid(dt_type_name_c) && typeid(*param_type) == typeid(dt_type_name_c)) {return_type = (symbol_c *)&time_type_name;} - else ERROR; - } - else ERROR; - } - else ERROR; - break; - case function_and: - case function_or: - if (current_param == 0) - if (is_binary_type(param_type)) - current_type = param_type; - else ERROR; - else if (is_same_type(current_type, param_type)) - return_type = common_type(current_type, param_type); - else ERROR; - break; - default: ERROR; - } - } - return (void *)return_type; - } - - void *compute_standard_function_il(il_function_call_c *symbol, symbol_c *param_type) { - /*symbol_c *current_type = NULL;*/ - symbol_c *return_type = NULL; - function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name); - if (current_function_type == function_none) ERROR; - - function_call_param_iterator_c function_call_param_iterator(symbol); - - int nb_param = 1; - if (symbol->il_operand_list != NULL) - nb_param += ((list_c *)symbol->il_operand_list)->n; - - for(int current_param = 0; current_param < nb_param; current_param++) { - - if (current_param != 0) { - symbol_c *param_name = NULL; - switch (current_function_type) { - default: ERROR; - } - - /* Get the value from a foo( = ) style call */ - symbol_c *param_value = function_call_param_iterator.search(param_name); - delete param_name; - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - - if (param_value == NULL) ERROR; - - param_type = (symbol_c *)param_value->accept(*this); - } - - switch (current_function_type) { - case function_sqrt: - if (current_param == 0 && is_real_type(param_type)) - return_type = param_type; - else ERROR; - break; - default: ERROR; - } - } - - return (void *)return_type; - } -#endif - - /*static bool_type_name_c bool_type_name;*/ - - /* A helper function... */ - void *compute_boolean_expression(symbol_c *left_type, symbol_c *right_type) { - if (!is_same_type(left_type, right_type)) - ERROR; - if (!is_bool_type(left_type) && !is_binary_type(left_type)) - ERROR; - if (typeid(*left_type) == typeid(constant_int_type_name_c)) {return (void *)right_type;} - else {return (void *)left_type;} - } - - /* A helper function... */ - void *compute_numeric_expression(symbol_c *left_type, symbol_c *right_type) { - if (!is_same_type(left_type, right_type)) - ERROR; - if (!is_integer_type(left_type) && !is_real_type(left_type)) - ERROR; - if ((typeid(*left_type) == typeid(constant_int_type_name_c)) || (typeid(*left_type) == typeid(constant_real_type_name_c))) {return (void *)right_type;} - else {return (void *)left_type;} - return NULL; - } - - /* a helper function... */ - symbol_c *base_type(symbol_c *symbol) { - return (symbol_c *)symbol->accept(search_base_type); - } - -/*********************/ -/* B 1.4 - Variables */ -/*********************/ - - void *visit(symbolic_variable_c *symbol) { - symbol_c *res; - - /* Nope, now we assume it is a variable, and determine its type... */ - res = search_varfb_instance_type->get_type(symbol); - if (NULL != res) return res; - - return NULL; - } - -/*************************************/ -/* B 1.4.2 - Multi-element variables */ -/*************************************/ - - void *visit(array_variable_c *symbol) { - symbol_c *res; - - /* Nope, now we assume it is a variable, and determine its type... */ - res = search_varfb_instance_type->get_type(symbol); - if (NULL != res) return res; - - return NULL; - } - - void *visit(structured_variable_c *symbol) { - symbol_c *res; - - /* Nope, now we assume it is a variable, and determine its type... */ - res = search_varfb_instance_type->get_type(symbol); - if (NULL != res) return res; - - return NULL; - } - -/***************************************/ -/* B.3 - Language ST (Structured Text) */ -/***************************************/ -/***********************/ -/* B 3.1 - Expressions */ -/***********************/ - void *visit(or_expression_c *symbol) { - symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); - symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); - return compute_boolean_expression(left_type, right_type); - } - - void *visit(xor_expression_c *symbol) { - symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); - symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); - return compute_boolean_expression(left_type, right_type); - } - - void *visit(and_expression_c *symbol) { - symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); - symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); - return compute_boolean_expression(left_type, right_type); - } - - void *visit(equ_expression_c *symbol) {return (void *)&bool_type_name;} - void *visit(notequ_expression_c *symbol) {return (void *)&bool_type_name;} - void *visit(lt_expression_c *symbol) {return (void *)&bool_type_name;} - void *visit(gt_expression_c *symbol) {return (void *)&bool_type_name;} - void *visit(le_expression_c *symbol) {return (void *)&bool_type_name;} - void *visit(ge_expression_c *symbol) {return (void *)&bool_type_name;} - - void *visit(add_expression_c *symbol) { - symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); - symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); - if (typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) {return (void *)&time_type_name;} - if (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) {return (void *)&tod_type_name;} - if (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) {return (void *)&dt_type_name;} - return compute_numeric_expression(left_type, right_type); - } - - void *visit(sub_expression_c *symbol) { - symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); - symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); - if (typeid(*left_type) == typeid(time_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) {return (void *)&time_type_name;} - if (typeid(*left_type) == typeid(date_type_name_c) && typeid(*right_type) == typeid(date_type_name_c)) {return (void *)&time_type_name;} - if (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) {return (void *)&tod_type_name;} - if (typeid(*left_type) == typeid(tod_type_name_c) && typeid(*right_type) == typeid(tod_type_name_c)) {return (void *)&time_type_name;} - if (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(time_type_name_c)) {return (void *)&dt_type_name;} - if (typeid(*left_type) == typeid(dt_type_name_c) && typeid(*right_type) == typeid(dt_type_name_c)) {return (void *)&time_type_name;} - return compute_numeric_expression(left_type, right_type); - } - - void *visit(mul_expression_c *symbol) { - symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); - symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); - if (typeid(*left_type) == typeid(time_type_name_c) && is_num_type(right_type)) { - return (void *)&time_type_name; - } - return compute_numeric_expression(left_type, right_type); - } - - void *visit(div_expression_c *symbol) { - symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); - symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); - if (typeid(*left_type) == typeid(time_type_name_c) && is_num_type(right_type)){ - return (void *)&time_type_name; - } - return compute_numeric_expression(left_type, right_type); - } - - void *visit(mod_expression_c *symbol) { - symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); - symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); - return compute_numeric_expression(left_type, right_type); - } - - void *visit(power_expression_c *symbol) { - symbol_c *left_type = base_type((symbol_c *)symbol->l_exp->accept(*this)); - symbol_c *right_type = base_type((symbol_c *)symbol->r_exp->accept(*this)); - if (is_real_type(left_type) && is_num_type(right_type)) { - return (void *)left_type; - } - ERROR; - return NULL; - } - - void *visit(neg_expression_c *symbol) { - symbol_c *exp_type = base_type((symbol_c *)symbol->exp->accept(*this)); - if (is_num_type(exp_type) || typeid(*exp_type) == typeid(time_type_name_c)){ - return (void *)exp_type; - } - ERROR; - return NULL; - } - - void *visit(not_expression_c *symbol) { - symbol_c *exp_type = base_type((symbol_c *)symbol->exp->accept(*this)); - return compute_boolean_expression(exp_type, exp_type); - } - - void *visit(function_invocation_c *symbol) { - function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name); - - if (f_decl == function_symtable.end_value()) { - void *res = compute_standard_function_st(symbol); - if (res == NULL) - ERROR; - return res; - } - - return base_type(f_decl->type_name); - } - -}; - -/*bool_type_name_c search_expression_type_c::bool_type_name;*/ - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/search_fb_instance_decl.cc --- a/stage4/generate_cc/search_fb_instance_decl.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,141 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* Returns the function block type declaration - * of a specific function block instance. - */ - - - -/* Returns the type name of a specific function block - * instance. This class will search the variable - * declarations inside the scope given to it - * searching for the declaration of the function - * block instance. - * - * The class constructor must be given the search scope - * (function, function block or program within which - * the function block instance was declared). - * - * This class will search the tree from the root given to the - * constructor. Another option would be to build a symbol table, - * and search that instead. Building the symbol table would be done - * while visiting the variable declaration objects in the parse - * tree. Unfortuantely, generate_cc_c does not visit these - * objects, delegating it to another class. This means that - * we would need another specialised class just to build the - * symbol table. We might just as well have a specialised class - * that searches the tree itself for the relevant info. This - * class is exactly that...! - */ -class search_fb_instance_decl_c: public search_visitor_c { - - private: - symbol_c *search_scope; - - symbol_c *search_name; - symbol_c *current_fb_type_name; - - public: - search_fb_instance_decl_c(symbol_c *search_scope) { - this->search_scope = search_scope; - this->current_fb_type_name = NULL; - } - - symbol_c *get_type_name(symbol_c *fb_instance_name) { - this->search_name = fb_instance_name; - return (symbol_c *)search_scope->accept(*this); - } - - public: -/***************************/ -/* B 0 - Programming Model */ -/***************************/ - void *visit(library_c *symbol) { - /* we do not want to search multiple declaration scopes, - * so we do not visit all the functions, fucntion blocks, etc... - */ - return NULL; - } - -/******************************************/ -/* B 1.4.3 - Declaration & Initialisation */ -/******************************************/ - -/* name_list ':' function_block_type_name ASSIGN structure_initialization */ -/* structure_initialization -> may be NULL ! */ - void *visit(fb_name_decl_c *symbol) { - current_fb_type_name = symbol->function_block_type_name; - return symbol->fb_name_list->accept(*this); - } - -/* name_list ',' fb_name */ - void *visit(fb_name_list_c *symbol) { - list_c *list = symbol; - for(int i = 0; i < list->n; i++) { - if (compare_identifiers(list->elements[i], search_name) == 0) - /* by now, current_fb_declaration should be != NULL */ - return current_fb_type_name; - } - return NULL; - } - -/**************************************/ -/* B.1.5 - Program organization units */ -/**************************************/ -/***********************/ -/* B 1.5.1 - Functions */ -/***********************/ - void *visit(function_declaration_c *symbol) { - /* no need to search through all the body, so we only - * visit the variable declarations...! - */ - return symbol->var_declarations_list->accept(*this); - } - -/*****************************/ -/* B 1.5.2 - Function Blocks */ -/*****************************/ - void *visit(function_block_declaration_c *symbol) { - /* no need to search through all the body, so we only - * visit the variable declarations...! - */ - return symbol->var_declarations->accept(*this); - } - -/**********************/ -/* B 1.5.3 - Programs */ -/**********************/ - void *visit(program_declaration_c *symbol) { - /* no need to search through all the body, so we only - * visit the variable declarations...! - */ - return symbol->var_declarations->accept(*this); - } -}; - - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/search_type_code.c --- a/stage4/generate_cc/search_type_code.c Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,26146 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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 lib - * generated code, do not edit by hand - */ - -void *compute_standard_function_st(function_invocation_c *symbol) { - - function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name); - function_call_param_iterator_c function_call_param_iterator(symbol); - search_expression_type_c* search_expression_type = this; - - switch(current_function_type){ - -/**** - *BOOL_TO_SINT - */ - case function_bool_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_sint*/ - break; - -/**** - *BOOL_TO_INT - */ - case function_bool_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_int*/ - break; - -/**** - *BOOL_TO_DINT - */ - case function_bool_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_dint*/ - break; - -/**** - *BOOL_TO_LINT - */ - case function_bool_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_lint*/ - break; - -/**** - *BOOL_TO_USINT - */ - case function_bool_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_usint*/ - break; - -/**** - *BOOL_TO_UINT - */ - case function_bool_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_uint*/ - break; - -/**** - *BOOL_TO_UDINT - */ - case function_bool_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_udint*/ - break; - -/**** - *BOOL_TO_ULINT - */ - case function_bool_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_ulint*/ - break; - -/**** - *BOOL_TO_REAL - */ - case function_bool_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_real*/ - break; - -/**** - *BOOL_TO_LREAL - */ - case function_bool_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_lreal*/ - break; - -/**** - *BOOL_TO_TIME - */ - case function_bool_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_time*/ - break; - -/**** - *BOOL_TO_DATE - */ - case function_bool_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_date*/ - break; - -/**** - *BOOL_TO_TOD - */ - case function_bool_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_tod*/ - break; - -/**** - *BOOL_TO_DT - */ - case function_bool_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_dt*/ - break; - -/**** - *BOOL_TO_STRING - */ - case function_bool_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_string*/ - break; - -/**** - *BOOL_TO_BYTE - */ - case function_bool_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_byte*/ - break; - -/**** - *BOOL_TO_WORD - */ - case function_bool_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_word*/ - break; - -/**** - *BOOL_TO_DWORD - */ - case function_bool_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_dword*/ - break; - -/**** - *BOOL_TO_LWORD - */ - case function_bool_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_lword*/ - break; - -/**** - *INT_TO_BOOL - */ - case function_int_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_bool*/ - break; - -/**** - *INT_TO_SINT - */ - case function_int_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_sint*/ - break; - -/**** - *INT_TO_DINT - */ - case function_int_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_dint*/ - break; - -/**** - *INT_TO_LINT - */ - case function_int_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_lint*/ - break; - -/**** - *INT_TO_USINT - */ - case function_int_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_usint*/ - break; - -/**** - *INT_TO_UINT - */ - case function_int_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_uint*/ - break; - -/**** - *INT_TO_UDINT - */ - case function_int_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_udint*/ - break; - -/**** - *INT_TO_ULINT - */ - case function_int_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_ulint*/ - break; - -/**** - *INT_TO_REAL - */ - case function_int_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_real*/ - break; - -/**** - *INT_TO_LREAL - */ - case function_int_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_lreal*/ - break; - -/**** - *INT_TO_TIME - */ - case function_int_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_time*/ - break; - -/**** - *INT_TO_DATE - */ - case function_int_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_date*/ - break; - -/**** - *INT_TO_TOD - */ - case function_int_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_tod*/ - break; - -/**** - *INT_TO_DT - */ - case function_int_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_dt*/ - break; - -/**** - *INT_TO_STRING - */ - case function_int_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_string*/ - break; - -/**** - *INT_TO_BYTE - */ - case function_int_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_byte*/ - break; - -/**** - *INT_TO_WORD - */ - case function_int_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_word*/ - break; - -/**** - *INT_TO_DWORD - */ - case function_int_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_dword*/ - break; - -/**** - *INT_TO_LWORD - */ - case function_int_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_lword*/ - break; - -/**** - *USINT_TO_BOOL - */ - case function_usint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_sint*/ - break; - -/**** - *USINT_TO_INT - */ - case function_usint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_lreal*/ - break; - -/**** - *USINT_TO_TIME - */ - case function_usint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_lword*/ - break; - -/**** - *ULINT_TO_BOOL - */ - case function_ulint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_bool*/ - break; - -/**** - *ULINT_TO_SINT - */ - case function_ulint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_sint*/ - break; - -/**** - *ULINT_TO_INT - */ - case function_ulint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_int*/ - break; - -/**** - *ULINT_TO_DINT - */ - case function_ulint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_dint*/ - break; - -/**** - *ULINT_TO_LINT - */ - case function_ulint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_lint*/ - break; - -/**** - *ULINT_TO_USINT - */ - case function_ulint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_usint*/ - break; - -/**** - *ULINT_TO_UINT - */ - case function_ulint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_uint*/ - break; - -/**** - *ULINT_TO_UDINT - */ - case function_ulint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_udint*/ - break; - -/**** - *ULINT_TO_REAL - */ - case function_ulint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_real*/ - break; - -/**** - *ULINT_TO_LREAL - */ - case function_ulint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_lreal*/ - break; - -/**** - *ULINT_TO_TIME - */ - case function_ulint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_time*/ - break; - -/**** - *ULINT_TO_DATE - */ - case function_ulint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_date*/ - break; - -/**** - *ULINT_TO_TOD - */ - case function_ulint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_tod*/ - break; - -/**** - *ULINT_TO_DT - */ - case function_ulint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_dt*/ - break; - -/**** - *ULINT_TO_STRING - */ - case function_ulint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_string*/ - break; - -/**** - *ULINT_TO_BYTE - */ - case function_ulint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_byte*/ - break; - -/**** - *ULINT_TO_WORD - */ - case function_ulint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_word*/ - break; - -/**** - *ULINT_TO_DWORD - */ - case function_ulint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_dword*/ - break; - -/**** - *ULINT_TO_LWORD - */ - case function_ulint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_bool*/ - break; - -/**** - *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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_lword*/ - break; - -/**** - *TIME_TO_SINT - */ - case function_time_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_sint*/ - break; - -/**** - *TIME_TO_INT - */ - case function_time_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_int*/ - break; - -/**** - *TIME_TO_DINT - */ - case function_time_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_dint*/ - break; - -/**** - *TIME_TO_LINT - */ - case function_time_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_lint*/ - break; - -/**** - *TIME_TO_USINT - */ - case function_time_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_usint*/ - break; - -/**** - *TIME_TO_UINT - */ - case function_time_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_uint*/ - break; - -/**** - *TIME_TO_UDINT - */ - case function_time_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_udint*/ - break; - -/**** - *TIME_TO_ULINT - */ - case function_time_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_ulint*/ - break; - -/**** - *TIME_TO_REAL - */ - case function_time_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_real*/ - break; - -/**** - *TIME_TO_LREAL - */ - case function_time_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_lreal*/ - break; - -/**** - *TIME_TO_STRING - */ - case function_time_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_string*/ - break; - -/**** - *TIME_TO_BYTE - */ - case function_time_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_byte*/ - break; - -/**** - *TIME_TO_WORD - */ - case function_time_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_word*/ - break; - -/**** - *TIME_TO_DWORD - */ - case function_time_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_dword*/ - break; - -/**** - *TIME_TO_LWORD - */ - case function_time_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_dword*/ - break; - -/**** - *TRUNC - */ - case function_trunc : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_trunc*/ - break; - -/**** - *BCD_TO_USINT - */ - case function_bcd_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bcd_to_usint*/ - break; - -/**** - *BCD_TO_UINT - */ - case function_bcd_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bcd_to_uint*/ - break; - -/**** - *BCD_TO_UDINT - */ - case function_bcd_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bcd_to_udint*/ - break; - -/**** - *BCD_TO_ULINT - */ - case function_bcd_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bcd_to_ulint*/ - break; - -/**** - *USINT_TO_BCD - */ - case function_usint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_bcd*/ - break; - -/**** - *UINT_TO_BCD - */ - case function_uint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_bcd*/ - break; - -/**** - *UDINT_TO_BCD - */ - case function_udint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_bcd*/ - break; - -/**** - *ULINT_TO_BCD - */ - case function_ulint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_bcd*/ - break; - -/**** - *DATE_AND_TIME_TO_TIME_OF_DAY - */ - case function_date_and_time_to_time_of_day : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_and_time_to_time_of_day*/ - break; - -/**** - *DATE_AND_TIME_TO_DATE - */ - case function_date_and_time_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_and_time_to_date*/ - break; - -/**** - *ABS - */ - case function_abs : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_num_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_abs*/ - break; - -/**** - *SQRT - */ - case function_sqrt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sqrt*/ - break; - -/**** - *LN - */ - case function_ln : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ln*/ - break; - -/**** - *LOG - */ - case function_log : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_log*/ - break; - -/**** - *EXP - */ - case function_exp : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_exp*/ - break; - -/**** - *SIN - */ - case function_sin : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sin*/ - break; - -/**** - *COS - */ - case function_cos : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_cos*/ - break; - -/**** - *TAN - */ - case function_tan : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tan*/ - break; - -/**** - *ASIN - */ - case function_asin : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_asin*/ - break; - -/**** - *ACOS - */ - case function_acos : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_acos*/ - break; - -/**** - *ATAN - */ - case function_atan : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_atan*/ - break; - -/**** - *ADD - */ - case function_add : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_add*/ - break; - -/**** - *MUL - */ - case function_mul : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mul*/ - break; - -/**** - *SUB - */ - case function_sub : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_sub*/ - break; - -/**** - *DIV - */ - case function_div : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_div*/ - break; - -/**** - *MOD - */ - case function_mod : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mod*/ - break; - -/**** - *EXPT - */ - case function_expt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_expt*/ - break; - -/**** - *MOVE - */ - case function_move : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_num_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_move*/ - break; - -/**** - *SHL - */ - case function_shl : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_binary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_shl*/ - break; - -/**** - *SHR - */ - case function_shr : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_binary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_shr*/ - break; - -/**** - *ROR - */ - case function_ror : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_nbinary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_ror*/ - break; - -/**** - *ROL - */ - case function_rol : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_nbinary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_rol*/ - break; - -/**** - *AND - */ - case function_and : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_binary_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_binary_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_and*/ - break; - -/**** - *OR - */ - case function_or : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_binary_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_binary_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_or*/ - break; - -/**** - *XOR - */ - case function_xor : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_binary_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_binary_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_xor*/ - break; - -/**** - *NOT - */ - case function_not : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_binary_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_not*/ - break; - -/**** - *SEL - */ - case function_sel : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("G"); - /* Get the value from a foo( = ) style call */ - symbol_c *G_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (G_param_value == NULL) - G_param_value = function_call_param_iterator.next(); - symbol_c *G_type_symbol = search_expression_type->get_type(G_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(G_type_symbol, last_type_symbol) ? search_expression_type->common_type(G_type_symbol, last_type_symbol) : G_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN0"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN0_param_value == NULL) - IN0_param_value = function_call_param_iterator.next(); - symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; - - - { - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_sel*/ - break; - -/**** - *MAX - */ - case function_max : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_max*/ - break; - -/**** - *MIN - */ - case function_min : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_min*/ - break; - -/**** - *LIMIT - */ - case function_limit : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("MN"); - /* Get the value from a foo( = ) style call */ - symbol_c *MN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (MN_param_value == NULL) - MN_param_value = function_call_param_iterator.next(); - symbol_c *MN_type_symbol = search_expression_type->get_type(MN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(MN_type_symbol, last_type_symbol) ? search_expression_type->common_type(MN_type_symbol, last_type_symbol) : MN_type_symbol ; - - - { - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - - { - - { - identifier_c param_name("MX"); - /* Get the value from a foo( = ) style call */ - symbol_c *MX_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (MX_param_value == NULL) - MX_param_value = function_call_param_iterator.next(); - symbol_c *MX_type_symbol = search_expression_type->get_type(MX_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(MX_type_symbol, last_type_symbol) ? search_expression_type->common_type(MX_type_symbol, last_type_symbol) : MX_type_symbol ; - - - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_limit*/ - break; - -/**** - *MUX - */ - case function_mux : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("K"); - /* Get the value from a foo( = ) style call */ - symbol_c *K_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (K_param_value == NULL) - K_param_value = function_call_param_iterator.next(); - symbol_c *K_type_symbol = search_expression_type->get_type(K_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(K_type_symbol, last_type_symbol) ? search_expression_type->common_type(K_type_symbol, last_type_symbol) : K_type_symbol ; - - if(search_expression_type->is_integer_type(K_type_symbol)) - { - - { - identifier_c param_name("IN0"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN0_param_value == NULL) - IN0_param_value = function_call_param_iterator.next(); - symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; - - - { - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mux*/ - break; - -/**** - *GT - */ - case function_gt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_gt*/ - break; - -/**** - *GE - */ - case function_ge : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_ge*/ - break; - -/**** - *EQ - */ - case function_eq : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_eq*/ - break; - -/**** - *LT - */ - case function_lt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_lt*/ - break; - -/**** - *LE - */ - case function_le : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_le*/ - break; - -/**** - *NE - */ - case function_ne : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_ne*/ - break; - -/**** - *LEN - */ - case function_len : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_len*/ - break; - -/**** - *LEFT - */ - case function_left : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_left*/ - break; - -/**** - *RIGHT - */ - case function_right : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_right*/ - break; - -/**** - *MID - */ - case function_mid : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mid*/ - break; - -/**** - *CONCAT - */ - case function_concat : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_concat*/ - break; - -/**** - *INSERT - */ - case function_insert : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_insert*/ - break; - -/**** - *DELETE - */ - case function_delete : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_delete*/ - break; - -/**** - *REPLACE - */ - case function_replace : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_replace*/ - break; - -/**** - *FIND - */ - case function_find : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_find*/ - break; - - case function_none : - ERROR; - } - return NULL; -} - -void *compute_standard_function_il(il_function_call_c *symbol, symbol_c *param_data_type) { - - function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name); - function_call_param_iterator_c function_call_param_iterator(symbol); - search_expression_type_c* search_expression_type = this; - - switch(current_function_type){ - -/**** - *BOOL_TO_SINT - */ - case function_bool_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_sint*/ - break; - -/**** - *BOOL_TO_INT - */ - case function_bool_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_int*/ - break; - -/**** - *BOOL_TO_DINT - */ - case function_bool_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_dint*/ - break; - -/**** - *BOOL_TO_LINT - */ - case function_bool_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_lint*/ - break; - -/**** - *BOOL_TO_USINT - */ - case function_bool_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_usint*/ - break; - -/**** - *BOOL_TO_UINT - */ - case function_bool_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_uint*/ - break; - -/**** - *BOOL_TO_UDINT - */ - case function_bool_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_udint*/ - break; - -/**** - *BOOL_TO_ULINT - */ - case function_bool_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_ulint*/ - break; - -/**** - *BOOL_TO_REAL - */ - case function_bool_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_real*/ - break; - -/**** - *BOOL_TO_LREAL - */ - case function_bool_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_lreal*/ - break; - -/**** - *BOOL_TO_TIME - */ - case function_bool_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_time*/ - break; - -/**** - *BOOL_TO_DATE - */ - case function_bool_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_date*/ - break; - -/**** - *BOOL_TO_TOD - */ - case function_bool_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_tod*/ - break; - -/**** - *BOOL_TO_DT - */ - case function_bool_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_dt*/ - break; - -/**** - *BOOL_TO_STRING - */ - case function_bool_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_string*/ - break; - -/**** - *BOOL_TO_BYTE - */ - case function_bool_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_byte*/ - break; - -/**** - *BOOL_TO_WORD - */ - case function_bool_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_word*/ - break; - -/**** - *BOOL_TO_DWORD - */ - case function_bool_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_dword*/ - break; - -/**** - *BOOL_TO_LWORD - */ - case function_bool_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bool_to_lword*/ - break; - -/**** - *SINT_TO_BOOL - */ - case function_sint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_bool*/ - break; - -/**** - *SINT_TO_INT - */ - case function_sint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_int*/ - break; - -/**** - *SINT_TO_DINT - */ - case function_sint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_dint*/ - break; - -/**** - *SINT_TO_LINT - */ - case function_sint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_lint*/ - break; - -/**** - *SINT_TO_USINT - */ - case function_sint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_usint*/ - break; - -/**** - *SINT_TO_UINT - */ - case function_sint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_uint*/ - break; - -/**** - *SINT_TO_UDINT - */ - case function_sint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_udint*/ - break; - -/**** - *SINT_TO_ULINT - */ - case function_sint_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_ulint*/ - break; - -/**** - *SINT_TO_REAL - */ - case function_sint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_real*/ - break; - -/**** - *SINT_TO_LREAL - */ - case function_sint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_lreal*/ - break; - -/**** - *SINT_TO_TIME - */ - case function_sint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_time*/ - break; - -/**** - *SINT_TO_DATE - */ - case function_sint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_date*/ - break; - -/**** - *SINT_TO_TOD - */ - case function_sint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_tod*/ - break; - -/**** - *SINT_TO_DT - */ - case function_sint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_dt*/ - break; - -/**** - *SINT_TO_STRING - */ - case function_sint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_string*/ - break; - -/**** - *SINT_TO_BYTE - */ - case function_sint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_byte*/ - break; - -/**** - *SINT_TO_WORD - */ - case function_sint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_word*/ - break; - -/**** - *SINT_TO_DWORD - */ - case function_sint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_dword*/ - break; - -/**** - *SINT_TO_LWORD - */ - case function_sint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sint_to_lword*/ - break; - -/**** - *INT_TO_BOOL - */ - case function_int_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_bool*/ - break; - -/**** - *INT_TO_SINT - */ - case function_int_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_sint*/ - break; - -/**** - *INT_TO_DINT - */ - case function_int_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_dint*/ - break; - -/**** - *INT_TO_LINT - */ - case function_int_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_lint*/ - break; - -/**** - *INT_TO_USINT - */ - case function_int_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_usint*/ - break; - -/**** - *INT_TO_UINT - */ - case function_int_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_uint*/ - break; - -/**** - *INT_TO_UDINT - */ - case function_int_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_udint*/ - break; - -/**** - *INT_TO_ULINT - */ - case function_int_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_ulint*/ - break; - -/**** - *INT_TO_REAL - */ - case function_int_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_real*/ - break; - -/**** - *INT_TO_LREAL - */ - case function_int_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_lreal*/ - break; - -/**** - *INT_TO_TIME - */ - case function_int_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_time*/ - break; - -/**** - *INT_TO_DATE - */ - case function_int_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_date*/ - break; - -/**** - *INT_TO_TOD - */ - case function_int_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_tod*/ - break; - -/**** - *INT_TO_DT - */ - case function_int_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_dt*/ - break; - -/**** - *INT_TO_STRING - */ - case function_int_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_string*/ - break; - -/**** - *INT_TO_BYTE - */ - case function_int_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_byte*/ - break; - -/**** - *INT_TO_WORD - */ - case function_int_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_word*/ - break; - -/**** - *INT_TO_DWORD - */ - case function_int_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_dword*/ - break; - -/**** - *INT_TO_LWORD - */ - case function_int_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_int_to_lword*/ - break; - -/**** - *DINT_TO_BOOL - */ - case function_dint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_bool*/ - break; - -/**** - *DINT_TO_SINT - */ - case function_dint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_sint*/ - break; - -/**** - *DINT_TO_INT - */ - case function_dint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_int*/ - break; - -/**** - *DINT_TO_LINT - */ - case function_dint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_lint*/ - break; - -/**** - *DINT_TO_USINT - */ - case function_dint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_usint*/ - break; - -/**** - *DINT_TO_UINT - */ - case function_dint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_uint*/ - break; - -/**** - *DINT_TO_UDINT - */ - case function_dint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_udint*/ - break; - -/**** - *DINT_TO_ULINT - */ - case function_dint_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_ulint*/ - break; - -/**** - *DINT_TO_REAL - */ - case function_dint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_real*/ - break; - -/**** - *DINT_TO_LREAL - */ - case function_dint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_lreal*/ - break; - -/**** - *DINT_TO_TIME - */ - case function_dint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_time*/ - break; - -/**** - *DINT_TO_DATE - */ - case function_dint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_date*/ - break; - -/**** - *DINT_TO_TOD - */ - case function_dint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_tod*/ - break; - -/**** - *DINT_TO_DT - */ - case function_dint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_dt*/ - break; - -/**** - *DINT_TO_STRING - */ - case function_dint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_string*/ - break; - -/**** - *DINT_TO_BYTE - */ - case function_dint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_byte*/ - break; - -/**** - *DINT_TO_WORD - */ - case function_dint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_word*/ - break; - -/**** - *DINT_TO_DWORD - */ - case function_dint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_dword*/ - break; - -/**** - *DINT_TO_LWORD - */ - case function_dint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dint_to_lword*/ - break; - -/**** - *LINT_TO_BOOL - */ - case function_lint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_bool*/ - break; - -/**** - *LINT_TO_SINT - */ - case function_lint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_sint*/ - break; - -/**** - *LINT_TO_INT - */ - case function_lint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_int*/ - break; - -/**** - *LINT_TO_DINT - */ - case function_lint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_dint*/ - break; - -/**** - *LINT_TO_USINT - */ - case function_lint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_usint*/ - break; - -/**** - *LINT_TO_UINT - */ - case function_lint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_uint*/ - break; - -/**** - *LINT_TO_UDINT - */ - case function_lint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_udint*/ - break; - -/**** - *LINT_TO_ULINT - */ - case function_lint_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_ulint*/ - break; - -/**** - *LINT_TO_REAL - */ - case function_lint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_real*/ - break; - -/**** - *LINT_TO_LREAL - */ - case function_lint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_lreal*/ - break; - -/**** - *LINT_TO_TIME - */ - case function_lint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_time*/ - break; - -/**** - *LINT_TO_DATE - */ - case function_lint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_date*/ - break; - -/**** - *LINT_TO_TOD - */ - case function_lint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_tod*/ - break; - -/**** - *LINT_TO_DT - */ - case function_lint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_dt*/ - break; - -/**** - *LINT_TO_STRING - */ - case function_lint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_string*/ - break; - -/**** - *LINT_TO_BYTE - */ - case function_lint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_byte*/ - break; - -/**** - *LINT_TO_WORD - */ - case function_lint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_word*/ - break; - -/**** - *LINT_TO_DWORD - */ - case function_lint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_dword*/ - break; - -/**** - *LINT_TO_LWORD - */ - case function_lint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lint_to_lword*/ - break; - -/**** - *USINT_TO_BOOL - */ - case function_usint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_bool*/ - break; - -/**** - *USINT_TO_SINT - */ - case function_usint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_sint*/ - break; - -/**** - *USINT_TO_INT - */ - case function_usint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_int*/ - break; - -/**** - *USINT_TO_DINT - */ - case function_usint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_dint*/ - break; - -/**** - *USINT_TO_LINT - */ - case function_usint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_lint*/ - break; - -/**** - *USINT_TO_UINT - */ - case function_usint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_uint*/ - break; - -/**** - *USINT_TO_UDINT - */ - case function_usint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_udint*/ - break; - -/**** - *USINT_TO_ULINT - */ - case function_usint_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_ulint*/ - break; - -/**** - *USINT_TO_REAL - */ - case function_usint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_real*/ - break; - -/**** - *USINT_TO_LREAL - */ - case function_usint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_lreal*/ - break; - -/**** - *USINT_TO_TIME - */ - case function_usint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_time*/ - break; - -/**** - *USINT_TO_DATE - */ - case function_usint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_date*/ - break; - -/**** - *USINT_TO_TOD - */ - case function_usint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_tod*/ - break; - -/**** - *USINT_TO_DT - */ - case function_usint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_dt*/ - break; - -/**** - *USINT_TO_STRING - */ - case function_usint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_string*/ - break; - -/**** - *USINT_TO_BYTE - */ - case function_usint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_byte*/ - break; - -/**** - *USINT_TO_WORD - */ - case function_usint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_word*/ - break; - -/**** - *USINT_TO_DWORD - */ - case function_usint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_dword*/ - break; - -/**** - *USINT_TO_LWORD - */ - case function_usint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_lword*/ - break; - -/**** - *UINT_TO_BOOL - */ - case function_uint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_bool*/ - break; - -/**** - *UINT_TO_SINT - */ - case function_uint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_sint*/ - break; - -/**** - *UINT_TO_INT - */ - case function_uint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_int*/ - break; - -/**** - *UINT_TO_DINT - */ - case function_uint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_dint*/ - break; - -/**** - *UINT_TO_LINT - */ - case function_uint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_lint*/ - break; - -/**** - *UINT_TO_USINT - */ - case function_uint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_usint*/ - break; - -/**** - *UINT_TO_UDINT - */ - case function_uint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_udint*/ - break; - -/**** - *UINT_TO_ULINT - */ - case function_uint_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_ulint*/ - break; - -/**** - *UINT_TO_REAL - */ - case function_uint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_real*/ - break; - -/**** - *UINT_TO_LREAL - */ - case function_uint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_lreal*/ - break; - -/**** - *UINT_TO_TIME - */ - case function_uint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_time*/ - break; - -/**** - *UINT_TO_DATE - */ - case function_uint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_date*/ - break; - -/**** - *UINT_TO_TOD - */ - case function_uint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_tod*/ - break; - -/**** - *UINT_TO_DT - */ - case function_uint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_dt*/ - break; - -/**** - *UINT_TO_STRING - */ - case function_uint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_string*/ - break; - -/**** - *UINT_TO_BYTE - */ - case function_uint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_byte*/ - break; - -/**** - *UINT_TO_WORD - */ - case function_uint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_word*/ - break; - -/**** - *UINT_TO_DWORD - */ - case function_uint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_dword*/ - break; - -/**** - *UINT_TO_LWORD - */ - case function_uint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_lword*/ - break; - -/**** - *UDINT_TO_BOOL - */ - case function_udint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_bool*/ - break; - -/**** - *UDINT_TO_SINT - */ - case function_udint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_sint*/ - break; - -/**** - *UDINT_TO_INT - */ - case function_udint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_int*/ - break; - -/**** - *UDINT_TO_DINT - */ - case function_udint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_dint*/ - break; - -/**** - *UDINT_TO_LINT - */ - case function_udint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_lint*/ - break; - -/**** - *UDINT_TO_USINT - */ - case function_udint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_usint*/ - break; - -/**** - *UDINT_TO_UINT - */ - case function_udint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_uint*/ - break; - -/**** - *UDINT_TO_ULINT - */ - case function_udint_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_ulint*/ - break; - -/**** - *UDINT_TO_REAL - */ - case function_udint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_real*/ - break; - -/**** - *UDINT_TO_LREAL - */ - case function_udint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_lreal*/ - break; - -/**** - *UDINT_TO_TIME - */ - case function_udint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_time*/ - break; - -/**** - *UDINT_TO_DATE - */ - case function_udint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_date*/ - break; - -/**** - *UDINT_TO_TOD - */ - case function_udint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_tod*/ - break; - -/**** - *UDINT_TO_DT - */ - case function_udint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_dt*/ - break; - -/**** - *UDINT_TO_STRING - */ - case function_udint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_string*/ - break; - -/**** - *UDINT_TO_BYTE - */ - case function_udint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_byte*/ - break; - -/**** - *UDINT_TO_WORD - */ - case function_udint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_word*/ - break; - -/**** - *UDINT_TO_DWORD - */ - case function_udint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_dword*/ - break; - -/**** - *UDINT_TO_LWORD - */ - case function_udint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_lword*/ - break; - -/**** - *ULINT_TO_BOOL - */ - case function_ulint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_bool*/ - break; - -/**** - *ULINT_TO_SINT - */ - case function_ulint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_sint*/ - break; - -/**** - *ULINT_TO_INT - */ - case function_ulint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_int*/ - break; - -/**** - *ULINT_TO_DINT - */ - case function_ulint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_dint*/ - break; - -/**** - *ULINT_TO_LINT - */ - case function_ulint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_lint*/ - break; - -/**** - *ULINT_TO_USINT - */ - case function_ulint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_usint*/ - break; - -/**** - *ULINT_TO_UINT - */ - case function_ulint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_uint*/ - break; - -/**** - *ULINT_TO_UDINT - */ - case function_ulint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_udint*/ - break; - -/**** - *ULINT_TO_REAL - */ - case function_ulint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_real*/ - break; - -/**** - *ULINT_TO_LREAL - */ - case function_ulint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_lreal*/ - break; - -/**** - *ULINT_TO_TIME - */ - case function_ulint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_time*/ - break; - -/**** - *ULINT_TO_DATE - */ - case function_ulint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_date*/ - break; - -/**** - *ULINT_TO_TOD - */ - case function_ulint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_tod*/ - break; - -/**** - *ULINT_TO_DT - */ - case function_ulint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_dt*/ - break; - -/**** - *ULINT_TO_STRING - */ - case function_ulint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_string*/ - break; - -/**** - *ULINT_TO_BYTE - */ - case function_ulint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_byte*/ - break; - -/**** - *ULINT_TO_WORD - */ - case function_ulint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_word*/ - break; - -/**** - *ULINT_TO_DWORD - */ - case function_ulint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_dword*/ - break; - -/**** - *ULINT_TO_LWORD - */ - case function_ulint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_lword*/ - break; - -/**** - *REAL_TO_BOOL - */ - case function_real_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_bool*/ - break; - -/**** - *REAL_TO_SINT - */ - case function_real_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_sint*/ - break; - -/**** - *REAL_TO_INT - */ - case function_real_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_int*/ - break; - -/**** - *REAL_TO_DINT - */ - case function_real_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_dint*/ - break; - -/**** - *REAL_TO_LINT - */ - case function_real_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_lint*/ - break; - -/**** - *REAL_TO_USINT - */ - case function_real_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_usint*/ - break; - -/**** - *REAL_TO_UINT - */ - case function_real_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_uint*/ - break; - -/**** - *REAL_TO_UDINT - */ - case function_real_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_udint*/ - break; - -/**** - *REAL_TO_ULINT - */ - case function_real_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_ulint*/ - break; - -/**** - *REAL_TO_LREAL - */ - case function_real_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_lreal*/ - break; - -/**** - *REAL_TO_TIME - */ - case function_real_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_time*/ - break; - -/**** - *REAL_TO_DATE - */ - case function_real_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_date*/ - break; - -/**** - *REAL_TO_TOD - */ - case function_real_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_tod*/ - break; - -/**** - *REAL_TO_DT - */ - case function_real_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_dt*/ - break; - -/**** - *REAL_TO_STRING - */ - case function_real_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_string*/ - break; - -/**** - *REAL_TO_BYTE - */ - case function_real_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_byte*/ - break; - -/**** - *REAL_TO_WORD - */ - case function_real_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_word*/ - break; - -/**** - *REAL_TO_DWORD - */ - case function_real_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_dword*/ - break; - -/**** - *REAL_TO_LWORD - */ - case function_real_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_real_to_lword*/ - break; - -/**** - *LREAL_TO_BOOL - */ - case function_lreal_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_bool*/ - break; - -/**** - *LREAL_TO_SINT - */ - case function_lreal_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_sint*/ - break; - -/**** - *LREAL_TO_INT - */ - case function_lreal_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_int*/ - break; - -/**** - *LREAL_TO_DINT - */ - case function_lreal_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_dint*/ - break; - -/**** - *LREAL_TO_LINT - */ - case function_lreal_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_lint*/ - break; - -/**** - *LREAL_TO_USINT - */ - case function_lreal_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_usint*/ - break; - -/**** - *LREAL_TO_UINT - */ - case function_lreal_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_uint*/ - break; - -/**** - *LREAL_TO_UDINT - */ - case function_lreal_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_udint*/ - break; - -/**** - *LREAL_TO_ULINT - */ - case function_lreal_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_ulint*/ - break; - -/**** - *LREAL_TO_REAL - */ - case function_lreal_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_real*/ - break; - -/**** - *LREAL_TO_TIME - */ - case function_lreal_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_time*/ - break; - -/**** - *LREAL_TO_DATE - */ - case function_lreal_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_date*/ - break; - -/**** - *LREAL_TO_TOD - */ - case function_lreal_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_tod*/ - break; - -/**** - *LREAL_TO_DT - */ - case function_lreal_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_dt*/ - break; - -/**** - *LREAL_TO_STRING - */ - case function_lreal_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_string*/ - break; - -/**** - *LREAL_TO_BYTE - */ - case function_lreal_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_byte*/ - break; - -/**** - *LREAL_TO_WORD - */ - case function_lreal_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_word*/ - break; - -/**** - *LREAL_TO_DWORD - */ - case function_lreal_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_dword*/ - break; - -/**** - *LREAL_TO_LWORD - */ - case function_lreal_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lreal_to_lword*/ - break; - -/**** - *TIME_TO_SINT - */ - case function_time_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_sint*/ - break; - -/**** - *TIME_TO_INT - */ - case function_time_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_int*/ - break; - -/**** - *TIME_TO_DINT - */ - case function_time_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_dint*/ - break; - -/**** - *TIME_TO_LINT - */ - case function_time_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_lint*/ - break; - -/**** - *TIME_TO_USINT - */ - case function_time_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_usint*/ - break; - -/**** - *TIME_TO_UINT - */ - case function_time_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_uint*/ - break; - -/**** - *TIME_TO_UDINT - */ - case function_time_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_udint*/ - break; - -/**** - *TIME_TO_ULINT - */ - case function_time_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_ulint*/ - break; - -/**** - *TIME_TO_REAL - */ - case function_time_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_real*/ - break; - -/**** - *TIME_TO_LREAL - */ - case function_time_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_lreal*/ - break; - -/**** - *TIME_TO_STRING - */ - case function_time_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_string*/ - break; - -/**** - *TIME_TO_BYTE - */ - case function_time_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_byte*/ - break; - -/**** - *TIME_TO_WORD - */ - case function_time_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_word*/ - break; - -/**** - *TIME_TO_DWORD - */ - case function_time_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_dword*/ - break; - -/**** - *TIME_TO_LWORD - */ - case function_time_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_time_to_lword*/ - break; - -/**** - *DATE_TO_SINT - */ - case function_date_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_sint*/ - break; - -/**** - *DATE_TO_INT - */ - case function_date_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_int*/ - break; - -/**** - *DATE_TO_DINT - */ - case function_date_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_dint*/ - break; - -/**** - *DATE_TO_LINT - */ - case function_date_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_lint*/ - break; - -/**** - *DATE_TO_USINT - */ - case function_date_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_usint*/ - break; - -/**** - *DATE_TO_UINT - */ - case function_date_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_uint*/ - break; - -/**** - *DATE_TO_UDINT - */ - case function_date_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_udint*/ - break; - -/**** - *DATE_TO_ULINT - */ - case function_date_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_ulint*/ - break; - -/**** - *DATE_TO_REAL - */ - case function_date_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_real*/ - break; - -/**** - *DATE_TO_LREAL - */ - case function_date_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_lreal*/ - break; - -/**** - *DATE_TO_STRING - */ - case function_date_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_string*/ - break; - -/**** - *DATE_TO_BYTE - */ - case function_date_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_byte*/ - break; - -/**** - *DATE_TO_WORD - */ - case function_date_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_word*/ - break; - -/**** - *DATE_TO_DWORD - */ - case function_date_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_dword*/ - break; - -/**** - *DATE_TO_LWORD - */ - case function_date_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_to_lword*/ - break; - -/**** - *TOD_TO_SINT - */ - case function_tod_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_sint*/ - break; - -/**** - *TOD_TO_INT - */ - case function_tod_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_int*/ - break; - -/**** - *TOD_TO_DINT - */ - case function_tod_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_dint*/ - break; - -/**** - *TOD_TO_LINT - */ - case function_tod_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_lint*/ - break; - -/**** - *TOD_TO_USINT - */ - case function_tod_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_usint*/ - break; - -/**** - *TOD_TO_UINT - */ - case function_tod_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_uint*/ - break; - -/**** - *TOD_TO_UDINT - */ - case function_tod_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_udint*/ - break; - -/**** - *TOD_TO_ULINT - */ - case function_tod_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_ulint*/ - break; - -/**** - *TOD_TO_REAL - */ - case function_tod_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_real*/ - break; - -/**** - *TOD_TO_LREAL - */ - case function_tod_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_lreal*/ - break; - -/**** - *TOD_TO_STRING - */ - case function_tod_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_string*/ - break; - -/**** - *TOD_TO_BYTE - */ - case function_tod_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_byte*/ - break; - -/**** - *TOD_TO_WORD - */ - case function_tod_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_word*/ - break; - -/**** - *TOD_TO_DWORD - */ - case function_tod_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_dword*/ - break; - -/**** - *TOD_TO_LWORD - */ - case function_tod_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tod_to_lword*/ - break; - -/**** - *DT_TO_SINT - */ - case function_dt_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_sint*/ - break; - -/**** - *DT_TO_INT - */ - case function_dt_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_int*/ - break; - -/**** - *DT_TO_DINT - */ - case function_dt_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_dint*/ - break; - -/**** - *DT_TO_LINT - */ - case function_dt_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_lint*/ - break; - -/**** - *DT_TO_USINT - */ - case function_dt_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_usint*/ - break; - -/**** - *DT_TO_UINT - */ - case function_dt_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_uint*/ - break; - -/**** - *DT_TO_UDINT - */ - case function_dt_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_udint*/ - break; - -/**** - *DT_TO_ULINT - */ - case function_dt_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_ulint*/ - break; - -/**** - *DT_TO_REAL - */ - case function_dt_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_real*/ - break; - -/**** - *DT_TO_LREAL - */ - case function_dt_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_lreal*/ - break; - -/**** - *DT_TO_STRING - */ - case function_dt_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_string*/ - break; - -/**** - *DT_TO_BYTE - */ - case function_dt_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_byte*/ - break; - -/**** - *DT_TO_WORD - */ - case function_dt_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_word*/ - break; - -/**** - *DT_TO_DWORD - */ - case function_dt_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_dword*/ - break; - -/**** - *DT_TO_LWORD - */ - case function_dt_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dt_to_lword*/ - break; - -/**** - *STRING_TO_BOOL - */ - case function_string_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_bool*/ - break; - -/**** - *STRING_TO_SINT - */ - case function_string_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_sint*/ - break; - -/**** - *STRING_TO_INT - */ - case function_string_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_int*/ - break; - -/**** - *STRING_TO_DINT - */ - case function_string_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_dint*/ - break; - -/**** - *STRING_TO_LINT - */ - case function_string_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_lint*/ - break; - -/**** - *STRING_TO_USINT - */ - case function_string_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_usint*/ - break; - -/**** - *STRING_TO_UINT - */ - case function_string_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_uint*/ - break; - -/**** - *STRING_TO_UDINT - */ - case function_string_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_udint*/ - break; - -/**** - *STRING_TO_ULINT - */ - case function_string_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_ulint*/ - break; - -/**** - *STRING_TO_REAL - */ - case function_string_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_real*/ - break; - -/**** - *STRING_TO_LREAL - */ - case function_string_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_lreal*/ - break; - -/**** - *STRING_TO_TIME - */ - case function_string_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_time*/ - break; - -/**** - *STRING_TO_DATE - */ - case function_string_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_date*/ - break; - -/**** - *STRING_TO_TOD - */ - case function_string_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_tod*/ - break; - -/**** - *STRING_TO_DT - */ - case function_string_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_dt*/ - break; - -/**** - *STRING_TO_BYTE - */ - case function_string_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_byte*/ - break; - -/**** - *STRING_TO_WORD - */ - case function_string_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_word*/ - break; - -/**** - *STRING_TO_DWORD - */ - case function_string_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_dword*/ - break; - -/**** - *STRING_TO_LWORD - */ - case function_string_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_string_to_lword*/ - break; - -/**** - *BYTE_TO_BOOL - */ - case function_byte_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_bool*/ - break; - -/**** - *BYTE_TO_SINT - */ - case function_byte_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_sint*/ - break; - -/**** - *BYTE_TO_INT - */ - case function_byte_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_int*/ - break; - -/**** - *BYTE_TO_DINT - */ - case function_byte_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_dint*/ - break; - -/**** - *BYTE_TO_LINT - */ - case function_byte_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_lint*/ - break; - -/**** - *BYTE_TO_USINT - */ - case function_byte_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_usint*/ - break; - -/**** - *BYTE_TO_UINT - */ - case function_byte_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_uint*/ - break; - -/**** - *BYTE_TO_UDINT - */ - case function_byte_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_udint*/ - break; - -/**** - *BYTE_TO_ULINT - */ - case function_byte_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_ulint*/ - break; - -/**** - *BYTE_TO_REAL - */ - case function_byte_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_real*/ - break; - -/**** - *BYTE_TO_LREAL - */ - case function_byte_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_lreal*/ - break; - -/**** - *BYTE_TO_TIME - */ - case function_byte_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_time*/ - break; - -/**** - *BYTE_TO_DATE - */ - case function_byte_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_date*/ - break; - -/**** - *BYTE_TO_TOD - */ - case function_byte_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_tod*/ - break; - -/**** - *BYTE_TO_DT - */ - case function_byte_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_dt*/ - break; - -/**** - *BYTE_TO_STRING - */ - case function_byte_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_string*/ - break; - -/**** - *BYTE_TO_WORD - */ - case function_byte_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_word*/ - break; - -/**** - *BYTE_TO_DWORD - */ - case function_byte_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_dword*/ - break; - -/**** - *BYTE_TO_LWORD - */ - case function_byte_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_byte_to_lword*/ - break; - -/**** - *WORD_TO_BOOL - */ - case function_word_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_bool*/ - break; - -/**** - *WORD_TO_SINT - */ - case function_word_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_sint*/ - break; - -/**** - *WORD_TO_INT - */ - case function_word_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_int*/ - break; - -/**** - *WORD_TO_DINT - */ - case function_word_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_dint*/ - break; - -/**** - *WORD_TO_LINT - */ - case function_word_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_lint*/ - break; - -/**** - *WORD_TO_USINT - */ - case function_word_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_usint*/ - break; - -/**** - *WORD_TO_UINT - */ - case function_word_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_uint*/ - break; - -/**** - *WORD_TO_UDINT - */ - case function_word_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_udint*/ - break; - -/**** - *WORD_TO_ULINT - */ - case function_word_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_ulint*/ - break; - -/**** - *WORD_TO_REAL - */ - case function_word_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_real*/ - break; - -/**** - *WORD_TO_LREAL - */ - case function_word_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_lreal*/ - break; - -/**** - *WORD_TO_TIME - */ - case function_word_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_time*/ - break; - -/**** - *WORD_TO_DATE - */ - case function_word_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_date*/ - break; - -/**** - *WORD_TO_TOD - */ - case function_word_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_tod*/ - break; - -/**** - *WORD_TO_DT - */ - case function_word_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_dt*/ - break; - -/**** - *WORD_TO_STRING - */ - case function_word_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_string*/ - break; - -/**** - *WORD_TO_BYTE - */ - case function_word_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_byte*/ - break; - -/**** - *WORD_TO_DWORD - */ - case function_word_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_dword*/ - break; - -/**** - *WORD_TO_LWORD - */ - case function_word_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_word_to_lword*/ - break; - -/**** - *DWORD_TO_BOOL - */ - case function_dword_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_bool*/ - break; - -/**** - *DWORD_TO_SINT - */ - case function_dword_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_sint*/ - break; - -/**** - *DWORD_TO_INT - */ - case function_dword_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_int*/ - break; - -/**** - *DWORD_TO_DINT - */ - case function_dword_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_dint*/ - break; - -/**** - *DWORD_TO_LINT - */ - case function_dword_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_lint*/ - break; - -/**** - *DWORD_TO_USINT - */ - case function_dword_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_usint*/ - break; - -/**** - *DWORD_TO_UINT - */ - case function_dword_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_uint*/ - break; - -/**** - *DWORD_TO_UDINT - */ - case function_dword_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_udint*/ - break; - -/**** - *DWORD_TO_ULINT - */ - case function_dword_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_ulint*/ - break; - -/**** - *DWORD_TO_REAL - */ - case function_dword_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_real*/ - break; - -/**** - *DWORD_TO_LREAL - */ - case function_dword_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_lreal*/ - break; - -/**** - *DWORD_TO_TIME - */ - case function_dword_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_time*/ - break; - -/**** - *DWORD_TO_DATE - */ - case function_dword_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_date*/ - break; - -/**** - *DWORD_TO_TOD - */ - case function_dword_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_tod*/ - break; - -/**** - *DWORD_TO_DT - */ - case function_dword_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_dt*/ - break; - -/**** - *DWORD_TO_STRING - */ - case function_dword_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_string*/ - break; - -/**** - *DWORD_TO_BYTE - */ - case function_dword_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_byte*/ - break; - -/**** - *DWORD_TO_WORD - */ - case function_dword_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_word*/ - break; - -/**** - *DWORD_TO_LWORD - */ - case function_dword_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_dword_to_lword*/ - break; - -/**** - *LWORD_TO_BOOL - */ - case function_lword_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_bool*/ - break; - -/**** - *LWORD_TO_SINT - */ - case function_lword_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_sint*/ - break; - -/**** - *LWORD_TO_INT - */ - case function_lword_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_int*/ - break; - -/**** - *LWORD_TO_DINT - */ - case function_lword_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_dint*/ - break; - -/**** - *LWORD_TO_LINT - */ - case function_lword_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_lint*/ - break; - -/**** - *LWORD_TO_USINT - */ - case function_lword_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_usint*/ - break; - -/**** - *LWORD_TO_UINT - */ - case function_lword_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_uint*/ - break; - -/**** - *LWORD_TO_UDINT - */ - case function_lword_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_udint*/ - break; - -/**** - *LWORD_TO_ULINT - */ - case function_lword_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_ulint*/ - break; - -/**** - *LWORD_TO_REAL - */ - case function_lword_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_real*/ - break; - -/**** - *LWORD_TO_LREAL - */ - case function_lword_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_lreal*/ - break; - -/**** - *LWORD_TO_TIME - */ - case function_lword_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_time*/ - break; - -/**** - *LWORD_TO_DATE - */ - case function_lword_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_date*/ - break; - -/**** - *LWORD_TO_TOD - */ - case function_lword_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_tod*/ - break; - -/**** - *LWORD_TO_DT - */ - case function_lword_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_dt*/ - break; - -/**** - *LWORD_TO_STRING - */ - case function_lword_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_string*/ - break; - -/**** - *LWORD_TO_BYTE - */ - case function_lword_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_byte*/ - break; - -/**** - *LWORD_TO_WORD - */ - case function_lword_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_word*/ - break; - -/**** - *LWORD_TO_DWORD - */ - case function_lword_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_lword_to_dword*/ - break; - -/**** - *TRUNC - */ - case function_trunc : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_trunc*/ - break; - -/**** - *BCD_TO_USINT - */ - case function_bcd_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bcd_to_usint*/ - break; - -/**** - *BCD_TO_UINT - */ - case function_bcd_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bcd_to_uint*/ - break; - -/**** - *BCD_TO_UDINT - */ - case function_bcd_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bcd_to_udint*/ - break; - -/**** - *BCD_TO_ULINT - */ - case function_bcd_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_bcd_to_ulint*/ - break; - -/**** - *USINT_TO_BCD - */ - case function_usint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_usint_to_bcd*/ - break; - -/**** - *UINT_TO_BCD - */ - case function_uint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_uint_to_bcd*/ - break; - -/**** - *UDINT_TO_BCD - */ - case function_udint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_udint_to_bcd*/ - break; - -/**** - *ULINT_TO_BCD - */ - case function_ulint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ulint_to_bcd*/ - break; - -/**** - *DATE_AND_TIME_TO_TIME_OF_DAY - */ - case function_date_and_time_to_time_of_day : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_and_time_to_time_of_day*/ - break; - -/**** - *DATE_AND_TIME_TO_DATE - */ - case function_date_and_time_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_date_and_time_to_date*/ - break; - -/**** - *ABS - */ - case function_abs : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_abs*/ - break; - -/**** - *SQRT - */ - case function_sqrt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sqrt*/ - break; - -/**** - *LN - */ - case function_ln : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_ln*/ - break; - -/**** - *LOG - */ - case function_log : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_log*/ - break; - -/**** - *EXP - */ - case function_exp : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_exp*/ - break; - -/**** - *SIN - */ - case function_sin : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_sin*/ - break; - -/**** - *COS - */ - case function_cos : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_cos*/ - break; - -/**** - *TAN - */ - case function_tan : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_tan*/ - break; - -/**** - *ASIN - */ - case function_asin : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_asin*/ - break; - -/**** - *ACOS - */ - case function_acos : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_acos*/ - break; - -/**** - *ATAN - */ - case function_atan : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_atan*/ - break; - -/**** - *ADD - */ - case function_add : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_add*/ - break; - -/**** - *MUL - */ - case function_mul : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mul*/ - break; - -/**** - *SUB - */ - case function_sub : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_sub*/ - break; - -/**** - *DIV - */ - case function_div : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_div*/ - break; - -/**** - *MOD - */ - case function_mod : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mod*/ - break; - -/**** - *EXPT - */ - case function_expt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_expt*/ - break; - -/**** - *MOVE - */ - case function_move : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_num_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_move*/ - break; - -/**** - *SHL - */ - case function_shl : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_binary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_shl*/ - break; - -/**** - *SHR - */ - case function_shr : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_binary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_shr*/ - break; - -/**** - *ROR - */ - case function_ror : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_nbinary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_ror*/ - break; - -/**** - *ROL - */ - case function_rol : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_nbinary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_rol*/ - break; - -/**** - *AND - */ - case function_and : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_binary_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_binary_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_and*/ - break; - -/**** - *OR - */ - case function_or : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_binary_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_binary_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_or*/ - break; - -/**** - *XOR - */ - case function_xor : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_binary_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_binary_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_xor*/ - break; - -/**** - *NOT - */ - case function_not : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_binary_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_not*/ - break; - -/**** - *SEL - */ - case function_sel : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *G_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN0"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN0_param_value == NULL) - IN0_param_value = function_call_param_iterator.next(); - symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; - - - { - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_sel*/ - break; - -/**** - *MAX - */ - case function_max : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_max*/ - break; - -/**** - *MIN - */ - case function_min : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_min*/ - break; - -/**** - *LIMIT - */ - case function_limit : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *MN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - - { - - { - identifier_c param_name("MX"); - /* Get the value from a foo( = ) style call */ - symbol_c *MX_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (MX_param_value == NULL) - MX_param_value = function_call_param_iterator.next(); - symbol_c *MX_type_symbol = search_expression_type->get_type(MX_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(MX_type_symbol, last_type_symbol) ? search_expression_type->common_type(MX_type_symbol, last_type_symbol) : MX_type_symbol ; - - - { - - symbol_c * return_type_symbol = IN_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_limit*/ - break; - -/**** - *MUX - */ - case function_mux : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *K_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_integer_type(K_type_symbol)) - { - - { - identifier_c param_name("IN0"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN0_param_value == NULL) - IN0_param_value = function_call_param_iterator.next(); - symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; - - - { - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mux*/ - break; - -/**** - *GT - */ - case function_gt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_gt*/ - break; - -/**** - *GE - */ - case function_ge : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_ge*/ - break; - -/**** - *EQ - */ - case function_eq : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_eq*/ - break; - -/**** - *LT - */ - case function_lt : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_lt*/ - break; - -/**** - *LE - */ - case function_le : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_le*/ - break; - -/**** - *NE - */ - case function_ne : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_ne*/ - break; - -/**** - *LEN - */ - case function_len : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - }/*function_len*/ - break; - -/**** - *LEFT - */ - case function_left : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_left*/ - break; - -/**** - *RIGHT - */ - case function_right : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_right*/ - break; - -/**** - *MID - */ - case function_mid : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mid*/ - break; - -/**** - *CONCAT - */ - case function_concat : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_concat*/ - break; - -/**** - *INSERT - */ - case function_insert : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_insert*/ - break; - -/**** - *DELETE - */ - case function_delete : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_delete*/ - break; - -/**** - *REPLACE - */ - case function_replace : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_replace*/ - break; - -/**** - *FIND - */ - case function_find : - { - symbol_c *last_type_symbol = NULL; - - { - symbol_c *IN1_type_symbol = param_data_type; - last_type_symbol = param_data_type; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - return return_type_symbol; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_find*/ - break; - - case function_none : - ERROR; - } - return NULL; -} diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/search_var_instance_decl.cc --- a/stage4/generate_cc/search_var_instance_decl.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,505 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - -/* Determine the data type of a specific variable instance, including - * function block instances. - * A reference to the relevant variable declaration is returned. - * The variable instance may NOT be a member of a structure of a memeber - * of a structure of an element of an array of ... - * - * example: - * window.points[1].coordinate.x - * window.points[1].colour - * etc... ARE NOT ALLOWED! - * - * This class must only be passed the name of the variable that will appear - * in the variable declaration. In the above examples, this would be - * 'window' !! - * - * - * If you need to pass a complete name of a variable instance (such as - * 'window.points[1].coordinate.x') use the search_varfb_instance_type_c instead! - */ -/* Note that current_type_decl that this class returns may reference the - * name of a type, or the type declaration itself! - * For an example of the first, consider a variable declared as ... - * x : AAA; - * where the AAA type is previously declared as whatever. - * For an example of the second, consider a variable declared as ... - * x : array of int [10]; ----> is allowed - * - * If it is the first, we will return a reference to the name, if the second - * we return a reference to the declaration!! - */ -class search_var_instance_decl_c: public search_visitor_c { - - private: - symbol_c *search_scope; - symbol_c *search_name; - symbol_c *current_type_decl; - - /* variable used to store the type of variable currently being processed... */ - /* Will contain a single value of generate_cc_vardecl_c::XXXX_vt */ - unsigned int current_vartype; - - public: - search_var_instance_decl_c(symbol_c *search_scope) { - this->current_vartype = none_vt; - this->search_scope = search_scope; - this->search_name = NULL; - this->current_type_decl = NULL; - } - - symbol_c *get_decl(symbol_c *variable_instance_name) { - this->search_name = variable_instance_name; - return (symbol_c *)search_scope->accept(*this); - } - - unsigned int get_vartype() { - return current_vartype; - } - - public: - - /* the types of variables that need to be processed... */ - static const unsigned int none_vt = 0x0000; - static const unsigned int input_vt = 0x0001; // VAR_INPUT - static const unsigned int output_vt = 0x0002; // VAR_OUTPUT - static const unsigned int inoutput_vt = 0x0004; // VAR_IN_OUT - static const unsigned int private_vt = 0x0008; // VAR - static const unsigned int temp_vt = 0x0010; // VAR_TEMP - static const unsigned int external_vt = 0x0020; // VAR_EXTERNAL - static const unsigned int global_vt = 0x0040; // VAR_GLOBAL - static const unsigned int located_vt = 0x0080; // VAR AT - - -/***************************/ -/* B 0 - Programming Model */ -/***************************/ - void *visit(library_c *symbol) { - /* we do not want to search multiple declaration scopes, - * so we do not visit all the functions, fucntion blocks, etc... - */ - return NULL; - } - - - -/******************************************/ -/* B 1.4.3 - Declaration & Initialisation */ -/******************************************/ -/* edge -> The F_EDGE or R_EDGE directive */ -// SYM_REF2(edge_declaration_c, edge, var1_list) -// TODO - - void *visit(input_declarations_c *symbol) { - current_vartype = input_vt; - void *res = symbol->input_declaration_list->accept(*this); - if (res == NULL) { - current_vartype = none_vt; - } - return res; - } - -/* VAR_OUTPUT [RETAIN | NON_RETAIN] var_init_decl_list END_VAR */ -/* option -> may be NULL ! */ - void *visit(output_declarations_c *symbol) { - current_vartype = output_vt; - void *res = symbol->var_init_decl_list->accept(*this); - if (res == NULL) { - current_vartype = none_vt; - } - return res; - } - -/* VAR_IN_OUT var_declaration_list END_VAR */ - void *visit(input_output_declarations_c *symbol) { - current_vartype = inoutput_vt; - void *res = symbol->var_declaration_list->accept(*this); - if (res == NULL) { - current_vartype = none_vt; - } - return res; - } - -/* VAR [CONSTANT] var_init_decl_list END_VAR */ -/* option -> may be NULL ! */ -/* helper symbol for input_declarations */ - void *visit(var_declarations_c *symbol) { - current_vartype = private_vt; - void *res = symbol->var_init_decl_list->accept(*this); - if (res == NULL) { - current_vartype = none_vt; - } - return res; - } - -/* VAR RETAIN var_init_decl_list END_VAR */ - void *visit(retentive_var_declarations_c *symbol) { - current_vartype = private_vt; - void *res = symbol->var_init_decl_list->accept(*this); - if (res == NULL) { - current_vartype = none_vt; - } - return res; - } - -/* VAR [CONSTANT|RETAIN|NON_RETAIN] located_var_decl_list END_VAR */ -/* option -> may be NULL ! */ -//SYM_REF2(located_var_declarations_c, option, located_var_decl_list) - void *visit(located_var_declarations_c *symbol) { - current_vartype = located_vt; - void *res = symbol->located_var_decl_list->accept(*this); - if (res == NULL) { - current_vartype = none_vt; - } - return res; - } - -/*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */ -/* option -> may be NULL ! */ -//SYM_REF2(external_var_declarations_c, option, external_declaration_list) - void *visit(external_var_declarations_c *symbol) { - current_vartype = external_vt; - void *res = symbol->external_declaration_list->accept(*this); - if (res == NULL) { - current_vartype = none_vt; - } - return res; - } - -/*| VAR_GLOBAL [CONSTANT|RETAIN] global_var_decl_list END_VAR */ -/* option -> may be NULL ! */ -//SYM_REF2(global_var_declarations_c, option, global_var_decl_list) - void *visit(global_var_declarations_c *symbol) { - current_vartype = global_vt; - void *res = symbol->global_var_decl_list->accept(*this); - if (res == NULL) { - current_vartype = none_vt; - } - return res; - } - -/* var1_list is one of the following... - * simple_spec_init_c * - * subrange_spec_init_c * - * enumerated_spec_init_c * - */ -// SYM_REF2(var1_init_decl_c, var1_list, spec_init) - void *visit(var1_init_decl_c *symbol) { - current_type_decl = symbol->spec_init; - return symbol->var1_list->accept(*this); - } - -/* var1_list ',' variable_name */ -// SYM_LIST(var1_list_c) - void *visit(var1_list_c *symbol) { - list_c *list = symbol; - for(int i = 0; i < list->n; i++) { - if (compare_identifiers(list->elements[i], search_name) == 0) - /* by now, current_type_decl should be != NULL */ - return current_type_decl; - } - return NULL; - } - -/* name_list ':' function_block_type_name ASSIGN structure_initialization */ -/* structure_initialization -> may be NULL ! */ - void *visit(fb_name_decl_c *symbol) { - current_type_decl = symbol->function_block_type_name; - return symbol->fb_name_list->accept(*this); - } - -/* name_list ',' fb_name */ - void *visit(fb_name_list_c *symbol) { - list_c *list = symbol; - for(int i = 0; i < list->n; i++) { - if (compare_identifiers(list->elements[i], search_name) == 0) - /* by now, current_fb_declaration should be != NULL */ - return current_type_decl; - } - return NULL; - } - -/* var1_list ':' array_spec_init */ -// SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init) - void *visit(array_var_init_decl_c *symbol) { - current_type_decl = symbol->array_spec_init; - return symbol->var1_list->accept(*this); - } - -/* var1_list ':' initialized_structure */ -// SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure) - void *visit(structured_var_init_decl_c *symbol) { - current_type_decl = symbol->initialized_structure; - return symbol->var1_list->accept(*this); - } - -/* var1_list ':' array_specification */ -// SYM_REF2(array_var_declaration_c, var1_list, array_specification) - void *visit(array_var_declaration_c *symbol) { - current_type_decl = symbol->array_specification; - return symbol->var1_list->accept(*this); - } - -/* var1_list ':' structure_type_name */ -// SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name) - void *visit(structured_var_declaration_c *symbol) { - current_type_decl = symbol->structure_type_name; - return symbol->var1_list->accept(*this); - } - -/* [variable_name] location ':' located_var_spec_init */ -/* variable_name -> may be NULL ! */ -// SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused) -// TODO!! - -/* global_var_name ':' (simple_specification|subrange_specification|enumerated_specification|array_specification|prev_declared_structure_type_name|function_block_type_name */ -// SYM_REF2(external_declaration_c, global_var_name, specification) - void *visit(external_declaration_c *symbol) { - if (compare_identifiers(symbol->global_var_name, search_name) == 0) - return symbol->specification; - return NULL; - } - -/*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */ -/* type_specification ->may be NULL ! */ -// SYM_REF2(global_var_decl_c, global_var_spec, type_specification) - void *visit(global_var_decl_c *symbol) { - if (symbol->type_specification != NULL) { - current_type_decl = symbol->type_specification; - return symbol->global_var_spec->accept(*this); - } - else - return NULL; - } - -/*| global_var_name location */ -//SYM_REF2(global_var_spec_c, global_var_name, location) - void *visit(global_var_spec_c *symbol) { - if (symbol->global_var_name != NULL && compare_identifiers(symbol->global_var_name, search_name) == 0) - return current_type_decl; - else - return symbol->location->accept(*this); - } - -/*| global_var_list ',' global_var_name */ -//SYM_LIST(global_var_list_c) - void *visit(global_var_list_c *symbol) { - list_c *list = symbol; - for(int i = 0; i < list->n; i++) { - if (compare_identifiers(list->elements[i], search_name) == 0) - /* by now, current_type_decl should be != NULL */ - return current_type_decl; - } - return NULL; - } - -/* [variable_name] location ':' located_var_spec_init */ -/* variable_name -> may be NULL ! */ -//SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused) - void *visit(located_var_decl_c *symbol) { - if (symbol->variable_name != NULL && compare_identifiers(symbol->variable_name, search_name) == 0) { - return symbol->located_var_spec_init; - } - else - return NULL; - } - -/*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */ -/* type_specification ->may be NULL ! */ -// SYM_REF2(global_var_decl_c, global_var_spec, type_specification) -// TODO!! - -/*| global_var_name location */ -// SYM_REF2(global_var_spec_c, global_var_name, location) -// TODO!! - -/* AT direct_variable */ -// SYM_REF2(location_c, direct_variable, unused) -// TODO!! - -/*| global_var_list ',' global_var_name */ -// SYM_LIST(global_var_list_c) -// TODO!! - -/* var1_list ':' single_byte_string_spec */ -// SYM_REF2(single_byte_string_var_declaration_c, var1_list, single_byte_string_spec) - void *visit(single_byte_string_var_declaration_c *symbol) { - current_type_decl = symbol->single_byte_string_spec; - return symbol->var1_list->accept(*this); - } - -/* STRING ['[' integer ']'] [ASSIGN single_byte_character_string] */ -/* integer ->may be NULL ! */ -/* single_byte_character_string ->may be NULL ! */ -// SYM_REF2(single_byte_string_spec_c, integer, single_byte_character_string) -// TODO!! - -/* var1_list ':' double_byte_string_spec */ -// SYM_REF2(double_byte_string_var_declaration_c, var1_list, double_byte_string_spec) - void *visit(double_byte_string_var_declaration_c *symbol) { - current_type_decl = symbol->double_byte_string_spec; - return symbol->var1_list->accept(*this); - } - -/* WSTRING ['[' integer ']'] [ASSIGN double_byte_character_string] */ -/* integer ->may be NULL ! */ -/* double_byte_character_string ->may be NULL ! */ -// SYM_REF2(double_byte_string_spec_c, integer, double_byte_character_string) -// TODO!! - -/* variable_name incompl_location ':' var_spec */ -// SYM_REF4(incompl_located_var_decl_c, variable_name, incompl_location, var_spec, unused) -// TODO!! - -/* AT incompl_location_token */ -// SYM_TOKEN(incompl_location_c) -// TODO!! - - -/**************************************/ -/* B.1.5 - Program organization units */ -/**************************************/ -/***********************/ -/* B 1.5.1 - Functions */ -/***********************/ -// SYM_REF4(function_declaration_c, derived_function_name, type_name, var_declarations_list, function_body) - void *visit(function_declaration_c *symbol) { - /* functions have a variable named after themselves, to store - * the variable that will be returned!! - */ - if (compare_identifiers(symbol->derived_function_name, search_name) == 0) - return symbol->type_name; - - /* no need to search through all the body, so we only - * visit the variable declarations...! - */ - return symbol->var_declarations_list->accept(*this); - } - -/*****************************/ -/* B 1.5.2 - Function Blocks */ -/*****************************/ - void *visit(function_block_declaration_c *symbol) { - /* no need to search through all the body, so we only - * visit the variable declarations...! - */ - return symbol->var_declarations->accept(*this); - } - -/**********************/ -/* B 1.5.3 - Programs */ -/**********************/ - void *visit(program_declaration_c *symbol) { - /* no need to search through all the body, so we only - * visit the variable declarations...! - */ - return symbol->var_declarations->accept(*this); - } - - -/********************************/ -/* B 1.7 Configuration elements */ -/********************************/ - -/* -CONFIGURATION configuration_name - optional_global_var_declarations - (resource_declaration_list | single_resource_declaration) - optional_access_declarations - optional_instance_specific_initializations -END_CONFIGURATION -*/ -/* -SYM_REF6(configuration_declaration_c, configuration_name, global_var_declarations, resource_declarations, access_declarations, instance_specific_initializations, unused) -*/ - void *visit(configuration_declaration_c *symbol) { - /* no need to search through all the configuration, so we only - * visit the global variable declarations...! - */ - if (symbol->global_var_declarations != NULL) - return symbol->global_var_declarations->accept(*this); - else - return NULL; - } - -/* -RESOURCE resource_name ON resource_type_name - optional_global_var_declarations - single_resource_declaration -END_RESOURCE -*/ -// SYM_REF4(resource_declaration_c, resource_name, resource_type_name, global_var_declarations, resource_declaration) - void *visit(resource_declaration_c *symbol) { - /* no need to search through all the resource, so we only - * visit the global variable declarations...! - */ - if (symbol->global_var_declarations != NULL) - return symbol->global_var_declarations->accept(*this); - else - return NULL; - } - -/* task_configuration_list program_configuration_list */ -// SYM_REF2(single_resource_declaration_c, task_configuration_list, program_configuration_list) - void *visit(single_resource_declaration_c *symbol) { - /* no need to search through all the resource, - * and there is no global variable declarations...! - */ - return NULL; - } - -#if 0 -/*********************/ -/* B 1.4 - Variables */ -/*********************/ -SYM_REF2(symbolic_variable_c, var_name, unused) - -/********************************************/ -/* B.1.4.1 Directly Represented Variables */ -/********************************************/ -SYM_TOKEN(direct_variable_c) - -/*************************************/ -/* B.1.4.2 Multi-element Variables */ -/*************************************/ -/* subscripted_variable '[' subscript_list ']' */ -SYM_REF2(array_variable_c, subscripted_variable, subscript_list) - -/* subscript_list ',' subscript */ -SYM_LIST(subscript_list_c) - -/* record_variable '.' field_selector */ -/* WARNING: input and/or output variables of function blocks - * may be accessed as fields of a tructured variable! - * Code handling a structured_variable_c must take - * this into account! - */ -SYM_REF2(structured_variable_c, record_variable, field_selector) - - -#endif -}; - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/search_varfb_instance_type.cc --- a/stage4/generate_cc/search_varfb_instance_type.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,293 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - - -/* Determine the data type of a variable. - * The variable may be a simple variable, a function block instance, a - * struture element within a data structured type (a struct or a fb), or - * an array element. - * A mixture of array element of a structure element of a structure element - * of a .... is also suported! - * - * A reference to the relevant base type __definition__ is returned. - * This means that if we find that the variable is of type MY_INT, - * which was previously declared to be - * TYPE MY_INT: INT := 9; - * this class wil return INT, and __not__ MY_INT !! - * - * - * example: - * window.points[1].coordinate.x - * window.points[1].colour - * etc... ARE ALLOWED! - * - * This class must be passed the scope within which the - * variable was declared, and the variable name... - */ -class search_varfb_instance_type_c: public search_base_type_c { - private: - search_var_instance_decl_c search_var_instance_decl; - decompose_var_instance_name_c *decompose_var_instance_name; - symbol_c *current_structelement_name; - - public: - search_varfb_instance_type_c(symbol_c *search_scope): search_var_instance_decl(search_scope) { - this->decompose_var_instance_name = NULL; - this->current_structelement_name = NULL; - } - - - symbol_c *get_type(symbol_c *variable_name) { - this->current_structelement_name = NULL; - this->decompose_var_instance_name = new decompose_var_instance_name_c(variable_name); - if (NULL == decompose_var_instance_name) ERROR; - - /* find the part of the variable name that will appear in the - * variable declaration, for e.g., in window.point.x, this would be - * window! - */ - symbol_c *var_name_part = decompose_var_instance_name->next_part(); - if (NULL == var_name_part) ERROR; - - /* Now we try to find the variable instance declaration, to determine its type... */ - symbol_c *var_decl = search_var_instance_decl.get_decl(var_name_part); - if (NULL == var_decl) { - /* variable instance declaration not found! */ - return NULL; - } - - /* if it is a struct or function block, we must search the type - * of the struct or function block member. - * This is done by this class visiting the var_decl. - * This class, while visiting, will recursively call - * decompose_var_instance_name->get_next() when and if required... - */ - symbol_c *res = (symbol_c *)var_decl->accept(*this); - if (NULL == res) ERROR; - - /* make sure that we have decomposed all strcuture elements of the variable name */ - symbol_c *var_name = decompose_var_instance_name->next_part(); - if (NULL != var_name) ERROR; - - return res; - } - - unsigned int get_vartype(symbol_c *variable_name) { - this->current_structelement_name = NULL; - this->decompose_var_instance_name = new decompose_var_instance_name_c(variable_name); - if (NULL == decompose_var_instance_name) ERROR; - - /* find the part of the variable name that will appear in the - * variable declaration, for e.g., in window.point.x, this would be - * window! - */ - symbol_c *var_name_part = decompose_var_instance_name->next_part(); - if (NULL == var_name_part) ERROR; - - /* Now we try to find the variable instance declaration, to determine its type... */ - symbol_c *var_decl = search_var_instance_decl.get_decl(var_name_part); - if (NULL == var_decl) { - /* variable instance declaration not found! */ - return 0; - } - - /* if it is a struct or function block, we must search the type - * of the struct or function block member. - * This is done by this class visiting the var_decl. - * This class, while visiting, will recursively call - * decompose_var_instance_name->get_next() when and if required... - */ - unsigned int res = search_var_instance_decl.get_vartype(); - - /* make sure that we have decomposed all strcuture elements of the variable name */ - symbol_c *var_name = decompose_var_instance_name->next_part(); - if (NULL != var_name) ERROR; - - return res; - } - - private: - /* a helper function... */ - void *visit_list(list_c *list) { - if (NULL == current_structelement_name) ERROR; - - for(int i = 0; i < list->n; i++) { - void *res = list->elements[i]->accept(*this); - if (res != NULL) - return res; - } - /* not found! */ - return NULL; - } - - /* a helper function... */ - void *base_type(symbol_c *symbol) { - search_base_type_c search_base_type; - return symbol->accept(search_base_type); - } - - - private: - /* We override the base class' visitor to identifier_c. - * This is so because the base class does not consider a function block - * to be a type, unlike this class that allows a variable instance - * of a function block type... - */ - void *visit(identifier_c *type_name) { - /* look up the type declaration... */ - symbol_c *fb_decl = function_block_type_symtable.find_value(type_name); - if (fb_decl != function_block_type_symtable.end_value()) - /* Type declaration found!! */ - return fb_decl->accept(*this); - - /* No. It is not a function block, so we let - * the base class take care of it... - */ - return search_base_type_c::visit(type_name); - } - -/********************************/ -/* B 1.3.3 - Derived data types */ -/********************************/ -/* structure_type_name ':' structure_specification */ - void *visit(structure_type_declaration_c *symbol) { - return symbol->structure_specification->accept(*this); - /* NOTE: structure_specification will point to either a - * initialized_structure_c - * OR A - * structure_element_declaration_list_c - */ - } - -/* structure_type_name ASSIGN structure_initialization */ -/* structure_initialization may be NULL ! */ -// SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization) - void *visit(initialized_structure_c *symbol) { - /* make sure that we have decomposed all strcuture elements of the variable name */ - symbol_c *var_name = decompose_var_instance_name->next_part(); - if (NULL == var_name) { - /* this is it... ! - * No need to look any further... - */ - /* NOTE: we could simply do a - * return (void *)symbol; - * nevertheless, note that this search_varfb_instance_type_c - * class inherits from the search_base_type_c class, - * which means that it will usually return the base type, - * and not the derived type (*). If we are to be consistent, - * we should guarantee that we always return the base type. - * To do this we could use - * return (void *)symbol->accept(*this); - * since this class inherits from the search_base_type_c. - * However, in this case we don't want it to follow - * the structs as this search_varfb_instance_type_c does. - * We therefore have to create a new search_base_type_c - * instance to search through this type without going - * through the structs... - */ - return base_type(symbol->structure_type_name); - } - - /* now search the structure declaration */ - current_structelement_name = var_name; - /* recursively find out the data type of var_name... */ - return symbol->structure_type_name->accept(*this); - } - -/* helper symbol for structure_declaration */ -/* structure_declaration: STRUCT structure_element_declaration_list END_STRUCT */ -/* structure_element_declaration_list structure_element_declaration ';' */ - void *visit(structure_element_declaration_list_c *symbol) {return visit_list(symbol);} - -/* structure_element_name ':' spec_init */ - void *visit(structure_element_declaration_c *symbol) { - if (NULL == current_structelement_name) ERROR; - - if (compare_identifiers(symbol->structure_element_name, current_structelement_name) == 0) - return symbol->spec_init->accept(*this); - - return NULL; - } - -/* helper symbol for structure_initialization */ -/* structure_initialization: '(' structure_element_initialization_list ')' */ -/* structure_element_initialization_list ',' structure_element_initialization */ - void *visit(structure_element_initialization_list_c *symbol) {ERROR; return NULL;} /* should never get called... */ -/* structure_element_name ASSIGN value */ - void *visit(structure_element_initialization_c *symbol) {ERROR; return NULL;} /* should never get called... */ - - - -/**************************************/ -/* B.1.5 - Program organization units */ -/**************************************/ -/*****************************/ -/* B 1.5.2 - Function Blocks */ -/*****************************/ -/* FUNCTION_BLOCK derived_function_block_name io_OR_other_var_declarations function_block_body END_FUNCTION_BLOCK */ -// SYM_REF4(function_block_declaration_c, fblock_name, var_declarations, fblock_body, unused) - void *visit(function_block_declaration_c *symbol) { - /* make sure that we have decomposed all strcuture elements of the variable name */ - - symbol_c *var_name = decompose_var_instance_name->next_part(); - if (NULL == var_name) { - /* this is it... ! - * No need to look any further... - * Note also that, unlike for the struct types, a function block may - * not be defined based on another (i.e. no inheritance is allowed), - * so this function block is already the most base type. - * We simply return it. - */ - return (void *)symbol; - } - - /* now search the function block declaration for the variable... */ - search_var_instance_decl_c search_decl(symbol); - symbol_c *var_decl = search_decl.get_decl(var_name); - if (NULL == var_decl) { - /* variable instance declaration not found! */ - return NULL; - } - - /* We have found the declaration. - * Should we look any further? - */ - var_name = decompose_var_instance_name->next_part(); - if (NULL == var_name) { - /* this is it... ! */ - return base_type(var_decl); - } - - current_structelement_name = var_name; - /* recursively find out the data type of var_name... */ - return symbol->var_declarations->accept(*this); - } - -}; - - - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/spec_init_separator.cc --- a/stage4/generate_cc/spec_init_separator.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,169 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * Seperation of type specification and default value constructs - * (for e.g. simple_spec_init_c), into a type specificiation part, - * and a default value part. - */ - - - - -//#include /* required for NULL */ -//#include -//#include - -//#include "../../util/symtable.hh" - - - - - - - -class spec_init_sperator_c: public null_visitor_c { - private: - /* this is a singleton class... */ - static spec_init_sperator_c *class_instance; - static spec_init_sperator_c *get_class_instance(void) { - if (NULL == class_instance) - class_instance = new spec_init_sperator_c(); - - if (NULL == class_instance) - ERROR; - - return class_instance; - } - - private: - typedef enum {search_spec, search_init} search_what_t; - static search_what_t search_what; - - public: - /* the only two public functions... */ - static symbol_c *get_spec(symbol_c *spec_init) { - search_what = search_spec; - return (symbol_c *)spec_init->accept(*get_class_instance()); - } - - static symbol_c *get_init(symbol_c *spec_init) { - search_what = search_init; - return (symbol_c *)spec_init->accept(*get_class_instance()); - } - -// private: - public: /* probably needs to be public so it may be visited... !! */ - - -/*******************************************/ -/* B 1.1 - Letters, digits and identifiers */ -/*******************************************/ -// SYM_TOKEN(identifier_c) -void *visit(identifier_c *symbol) { - TRACE("spec_init_sperator_c::identifier_c"); - switch (search_what) { - /* if we ever get called sith a simple identifier_c, then it must be a previously declared type... */ - case search_spec: return symbol; - case search_init: return NULL; - } - ERROR; /* should never occur */ - return NULL; -} - - -/********************************/ -/* B 1.3.3 - Derived data types */ -/********************************/ - -/* simple_specification ASSIGN constant */ -void *visit(simple_spec_init_c *symbol) { - TRACE("spec_init_sperator_c::simple_spec_init_c"); - switch (search_what) { - case search_spec: return symbol->simple_specification; - case search_init: return symbol->constant; - } - ERROR; /* should never occur */ - return NULL; -} - -/* subrange_specification ASSIGN signed_integer */ -void *visit(subrange_spec_init_c *symbol) { - TRACE("spec_init_sperator_c::subrange_spec_init_c"); - switch (search_what) { - case search_spec: return symbol->subrange_specification; - case search_init: return symbol->signed_integer; - } - ERROR; /* should never occur */ - return NULL; -} - -/* enumerated_specification ASSIGN enumerated_value */ -void *visit(enumerated_spec_init_c *symbol) { - TRACE("spec_init_sperator_c::enumerated_spec_init_c"); - switch (search_what) { - case search_spec: return symbol->enumerated_specification; - case search_init: return symbol->enumerated_value; - } - ERROR; /* should never occur */ - return NULL; -} - -/* structure_type_name ASSIGN structure_initialization */ -/* structure_initialization may be NULL ! */ -//SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization) -void *visit(initialized_structure_c *symbol) { - TRACE("spec_init_sperator_c::initialized_structure_c"); - switch (search_what) { - case search_spec: return symbol->structure_type_name; - case search_init: return symbol->structure_initialization; - } - ERROR; /* should never occur */ - return NULL; -} - - -/******************************************/ -/* B 1.4.3 - Declaration & Initialisation */ -/******************************************/ - -/* fb_name_list ':' function_block_type_name ASSIGN structure_initialization */ -/* structure_initialization -> may be NULL ! */ -void *visit(fb_name_decl_c *symbol) { - TRACE("spec_init_sperator_c::fb_name_decl_c"); - switch (search_what) { - case search_spec: return symbol->function_block_type_name; - case search_init: return symbol->structure_initialization; - } - ERROR; /* should never occur */ - return NULL; -} - -}; /* class spec_init_sperator_c */ - - - -spec_init_sperator_c *spec_init_sperator_c ::class_instance = NULL; -spec_init_sperator_c::search_what_t spec_init_sperator_c::search_what; diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/st_code_gen.c --- a/stage4/generate_cc/st_code_gen.c Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,16973 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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 lib - * generated code, do not edit by hand - */ -switch(current_function_type){ - -/**** - *BOOL_TO_SINT - */ - case function_bool_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_sint*/ - break; - -/**** - *BOOL_TO_INT - */ - case function_bool_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_int*/ - break; - -/**** - *BOOL_TO_DINT - */ - case function_bool_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_dint*/ - break; - -/**** - *BOOL_TO_LINT - */ - case function_bool_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_lint*/ - break; - -/**** - *BOOL_TO_USINT - */ - case function_bool_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_usint*/ - break; - -/**** - *BOOL_TO_UINT - */ - case function_bool_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_uint*/ - break; - -/**** - *BOOL_TO_UDINT - */ - case function_bool_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_udint*/ - break; - -/**** - *BOOL_TO_ULINT - */ - case function_bool_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_ulint*/ - break; - -/**** - *BOOL_TO_REAL - */ - case function_bool_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_real*/ - break; - -/**** - *BOOL_TO_LREAL - */ - case function_bool_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_lreal*/ - break; - -/**** - *BOOL_TO_TIME - */ - case function_bool_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_time*/ - break; - -/**** - *BOOL_TO_DATE - */ - case function_bool_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_date*/ - break; - -/**** - *BOOL_TO_TOD - */ - case function_bool_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_tod*/ - break; - -/**** - *BOOL_TO_DT - */ - case function_bool_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_dt*/ - break; - -/**** - *BOOL_TO_STRING - */ - case function_bool_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bool_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_string*/ - break; - -/**** - *BOOL_TO_BYTE - */ - case function_bool_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_byte*/ - break; - -/**** - *BOOL_TO_WORD - */ - case function_bool_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_word*/ - break; - -/**** - *BOOL_TO_DWORD - */ - case function_bool_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_dword*/ - break; - -/**** - *BOOL_TO_LWORD - */ - case function_bool_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_bool_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__sint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_sint_to_lword*/ - break; - -/**** - *INT_TO_BOOL - */ - case function_int_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_bool*/ - break; - -/**** - *INT_TO_SINT - */ - case function_int_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_sint*/ - break; - -/**** - *INT_TO_DINT - */ - case function_int_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_dint*/ - break; - -/**** - *INT_TO_LINT - */ - case function_int_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_lint*/ - break; - -/**** - *INT_TO_USINT - */ - case function_int_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_usint*/ - break; - -/**** - *INT_TO_UINT - */ - case function_int_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_uint*/ - break; - -/**** - *INT_TO_UDINT - */ - case function_int_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_udint*/ - break; - -/**** - *INT_TO_ULINT - */ - case function_int_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_ulint*/ - break; - -/**** - *INT_TO_REAL - */ - case function_int_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_real*/ - break; - -/**** - *INT_TO_LREAL - */ - case function_int_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_lreal*/ - break; - -/**** - *INT_TO_TIME - */ - case function_int_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_time*/ - break; - -/**** - *INT_TO_DATE - */ - case function_int_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_date*/ - break; - -/**** - *INT_TO_TOD - */ - case function_int_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_tod*/ - break; - -/**** - *INT_TO_DT - */ - case function_int_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_dt*/ - break; - -/**** - *INT_TO_STRING - */ - case function_int_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__sint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_string*/ - break; - -/**** - *INT_TO_BYTE - */ - case function_int_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_byte*/ - break; - -/**** - *INT_TO_WORD - */ - case function_int_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_word*/ - break; - -/**** - *INT_TO_DWORD - */ - case function_int_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_dword*/ - break; - -/**** - *INT_TO_LWORD - */ - case function_int_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::int_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_int_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__sint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dint_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__sint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lint_to_lword*/ - break; - -/**** - *USINT_TO_BOOL - */ - case function_usint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_sint*/ - break; - -/**** - *USINT_TO_INT - */ - case function_usint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_lreal*/ - break; - -/**** - *USINT_TO_TIME - */ - case function_usint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_lword*/ - break; - -/**** - *ULINT_TO_BOOL - */ - case function_ulint_to_bool : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_bool*/ - break; - -/**** - *ULINT_TO_SINT - */ - case function_ulint_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_sint*/ - break; - -/**** - *ULINT_TO_INT - */ - case function_ulint_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_int*/ - break; - -/**** - *ULINT_TO_DINT - */ - case function_ulint_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_dint*/ - break; - -/**** - *ULINT_TO_LINT - */ - case function_ulint_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_lint*/ - break; - -/**** - *ULINT_TO_USINT - */ - case function_ulint_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_usint*/ - break; - -/**** - *ULINT_TO_UINT - */ - case function_ulint_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_uint*/ - break; - -/**** - *ULINT_TO_UDINT - */ - case function_ulint_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_udint*/ - break; - -/**** - *ULINT_TO_REAL - */ - case function_ulint_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_real*/ - break; - -/**** - *ULINT_TO_LREAL - */ - case function_ulint_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_lreal*/ - break; - -/**** - *ULINT_TO_TIME - */ - case function_ulint_to_time : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_time*/ - break; - -/**** - *ULINT_TO_DATE - */ - case function_ulint_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_date*/ - break; - -/**** - *ULINT_TO_TOD - */ - case function_ulint_to_tod : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_tod*/ - break; - -/**** - *ULINT_TO_DT - */ - case function_ulint_to_dt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_dt*/ - break; - -/**** - *ULINT_TO_STRING - */ - case function_ulint_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_string*/ - break; - -/**** - *ULINT_TO_BYTE - */ - case function_ulint_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_byte*/ - break; - -/**** - *ULINT_TO_WORD - */ - case function_ulint_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_word*/ - break; - -/**** - *ULINT_TO_DWORD - */ - case function_ulint_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_dword*/ - break; - -/**** - *ULINT_TO_LWORD - */ - case function_ulint_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_bool*/ - break; - -/**** - *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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_real_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__real_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lreal_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lreal_to_lword*/ - break; - -/**** - *TIME_TO_SINT - */ - case function_time_to_sint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_sint*/ - break; - -/**** - *TIME_TO_INT - */ - case function_time_to_int : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_int*/ - break; - -/**** - *TIME_TO_DINT - */ - case function_time_to_dint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_dint*/ - break; - -/**** - *TIME_TO_LINT - */ - case function_time_to_lint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_lint*/ - break; - -/**** - *TIME_TO_USINT - */ - case function_time_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_usint*/ - break; - -/**** - *TIME_TO_UINT - */ - case function_time_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_uint*/ - break; - -/**** - *TIME_TO_UDINT - */ - case function_time_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_udint*/ - break; - -/**** - *TIME_TO_ULINT - */ - case function_time_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_ulint*/ - break; - -/**** - *TIME_TO_REAL - */ - case function_time_to_real : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_real*/ - break; - -/**** - *TIME_TO_LREAL - */ - case function_time_to_lreal : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_lreal*/ - break; - -/**** - *TIME_TO_STRING - */ - case function_time_to_string : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_string*/ - break; - -/**** - *TIME_TO_BYTE - */ - case function_time_to_byte : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_byte*/ - break; - -/**** - *TIME_TO_WORD - */ - case function_time_to_word : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_word*/ - break; - -/**** - *TIME_TO_DWORD - */ - case function_time_to_dword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_dword*/ - break; - -/**** - *TIME_TO_LWORD - */ - case function_time_to_lword : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_time_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__date_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__tod_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tod_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__dt_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__time_to_int("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dt_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_bool("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_sint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_sint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_sint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_sint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_real("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_bit("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_bit("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_bit("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__string_to_bit("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_string_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bit_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_byte_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bit_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_dword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_word_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bit_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_dword_to_lword*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_bool*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_sint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_int*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_dint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_lint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_usint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_uint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_udint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_ulint*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::real_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_real*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_lreal*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_time*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_date*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_tod*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__int_to_time("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_dt*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bit_to_string("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_string*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_byte*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::word_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_word*/ - 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( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_lword_to_dword*/ - break; - -/**** - *TRUNC - */ - case function_trunc : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - s4o.print("(int)"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_trunc*/ - break; - -/**** - *BCD_TO_USINT - */ - case function_bcd_to_usint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::byte_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bcd_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bcd_to_usint*/ - break; - -/**** - *BCD_TO_UINT - */ - case function_bcd_to_uint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::word_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bcd_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bcd_to_uint*/ - break; - -/**** - *BCD_TO_UDINT - */ - case function_bcd_to_udint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bcd_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bcd_to_udint*/ - break; - -/**** - *BCD_TO_ULINT - */ - case function_bcd_to_ulint : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::lword_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__bcd_to_uint("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_bcd_to_ulint*/ - break; - -/**** - *USINT_TO_BCD - */ - case function_usint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::usint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_bcd("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_usint_to_bcd*/ - break; - -/**** - *UINT_TO_BCD - */ - case function_uint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::uint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_bcd("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_uint_to_bcd*/ - break; - -/**** - *UDINT_TO_BCD - */ - case function_udint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_bcd("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_udint_to_bcd*/ - break; - -/**** - *ULINT_TO_BCD - */ - case function_ulint_to_bcd : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::ulint_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name; - s4o.print("("); - return_type_symbol->accept(*this); - s4o.print(")__uint_to_bcd("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ulint_to_bcd*/ - break; - -/**** - *DATE_AND_TIME_TO_TIME_OF_DAY - */ - case function_date_and_time_to_time_of_day : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("__date_and_time_to_time_of_day("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_and_time_to_time_of_day*/ - break; - -/**** - *DATE_AND_TIME_TO_DATE - */ - case function_date_and_time_to_date : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::date_type_name; - s4o.print("__date_and_time_to_date("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_date_and_time_to_date*/ - break; - -/**** - *ABS - */ - case function_abs : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_num_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("__abs_"); - IN_type_symbol->accept(*this); - s4o.print("("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_abs*/ - break; - -/**** - *SQRT - */ - case function_sqrt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("sqrt("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sqrt*/ - break; - -/**** - *LN - */ - case function_ln : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("ln("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_ln*/ - break; - -/**** - *LOG - */ - case function_log : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("log("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_log*/ - break; - -/**** - *EXP - */ - case function_exp : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("exp("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_exp*/ - break; - -/**** - *SIN - */ - case function_sin : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("sin("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_sin*/ - break; - -/**** - *COS - */ - case function_cos : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("cos("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_cos*/ - break; - -/**** - *TAN - */ - case function_tan : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("tan("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_tan*/ - break; - -/**** - *ASIN - */ - case function_asin : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("asin("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_asin*/ - break; - -/**** - *ACOS - */ - case function_acos : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("acos("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_acos*/ - break; - -/**** - *ATAN - */ - case function_atan : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_real_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("atan("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_atan*/ - break; - -/**** - *ADD - */ - case function_add : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("+\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print("+\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("__time_add("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("__time_add("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_add("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_add*/ - break; - -/**** - *MUL - */ - case function_mul : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("*\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print("*\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_mul("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mul*/ - break; - -/**** - *SUB - */ - case function_sub : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("-\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_sub("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_sub("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("__time_sub("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_sub("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name; - s4o.print("__time_sub("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_sub("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_sub*/ - break; - -/**** - *DIV - */ - case function_div : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("/\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::time_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::time_type_name; - s4o.print("__time_div("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_div*/ - break; - -/**** - *MOD - */ - case function_mod : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("%\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mod*/ - break; - -/**** - *EXPT - */ - case function_expt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_num_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_num_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.print("pow("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_expt*/ - break; - -/**** - *MOVE - */ - case function_move : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_num_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_move*/ - break; - -/**** - *SHL - */ - case function_shl : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_binary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - IN_param_value->accept(*this); - s4o.print("<<"); - N_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_shl*/ - break; - -/**** - *SHR - */ - case function_shr : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_binary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - IN_param_value->accept(*this); - s4o.print(">>"); - N_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_shr*/ - break; - -/**** - *ROR - */ - case function_ror : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_nbinary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("__ror_"); - IN_type_symbol->accept(*this); - s4o.print("("); - IN_param_value->accept(*this); - s4o.print(", "); - N_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_ror*/ - break; - -/**** - *ROL - */ - case function_rol : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_nbinary_type(IN_type_symbol)) - { - - { - identifier_c param_name("N"); - /* Get the value from a foo( = ) style call */ - symbol_c *N_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (N_param_value == NULL) - N_param_value = function_call_param_iterator.next(); - symbol_c *N_type_symbol = search_expression_type->get_type(N_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(N_type_symbol, last_type_symbol) ? search_expression_type->common_type(N_type_symbol, last_type_symbol) : N_type_symbol ; - - if(search_expression_type->is_integer_type(N_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("__rol_"); - IN_type_symbol->accept(*this); - s4o.print("("); - IN_param_value->accept(*this); - s4o.print(", "); - N_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_rol*/ - break; - -/**** - *AND - */ - case function_and : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_binary_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_binary_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("("); - if (search_expression_type->is_bool_type(last_type_symbol)) - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("&\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print("&\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - if (search_expression_type->is_bool_type(last_type_symbol)) { - s4o.print("&1"); - s4o.print(")"); - } - s4o.print(""); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_and*/ - break; - -/**** - *OR - */ - case function_or : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_binary_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_binary_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("("); - if (search_expression_type->is_bool_type(last_type_symbol)) - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("|\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print("|\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - if (search_expression_type->is_bool_type(last_type_symbol)) { - s4o.print("&1"); - s4o.print(")"); - } - s4o.print(""); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_or*/ - break; - -/**** - *XOR - */ - case function_xor : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_binary_type(IN1_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_binary_type(IN2_type_symbol)) - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("("); - if (search_expression_type->is_bool_type(last_type_symbol)) - s4o.print("(\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print("^\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print("^\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - if (search_expression_type->is_bool_type(last_type_symbol)) { - s4o.print("&1"); - s4o.print(")"); - } - s4o.print(""); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_xor*/ - break; - -/**** - *NOT - */ - case function_not : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_binary_type(IN_type_symbol)) - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("~"); - IN_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - }/*function_not*/ - break; - -/**** - *SEL - */ - case function_sel : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("G"); - /* Get the value from a foo( = ) style call */ - symbol_c *G_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (G_param_value == NULL) - G_param_value = function_call_param_iterator.next(); - symbol_c *G_type_symbol = search_expression_type->get_type(G_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(G_type_symbol, last_type_symbol) ? search_expression_type->common_type(G_type_symbol, last_type_symbol) : G_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::bool_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN0"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN0_param_value == NULL) - IN0_param_value = function_call_param_iterator.next(); - symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; - - - { - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - G_param_value->accept(*this); - s4o.print(" ? "); - IN1_param_value->accept(*this); - s4o.print(" : "); - IN0_param_value->accept(*this); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_sel*/ - break; - -/**** - *MAX - */ - case function_max : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("__max_"); - return_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_max*/ - break; - -/**** - *MIN - */ - case function_min : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("__min_"); - return_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_min*/ - break; - -/**** - *LIMIT - */ - case function_limit : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("MN"); - /* Get the value from a foo( = ) style call */ - symbol_c *MN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (MN_param_value == NULL) - MN_param_value = function_call_param_iterator.next(); - symbol_c *MN_type_symbol = search_expression_type->get_type(MN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(MN_type_symbol, last_type_symbol) ? search_expression_type->common_type(MN_type_symbol, last_type_symbol) : MN_type_symbol ; - - - { - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - - { - - { - identifier_c param_name("MX"); - /* Get the value from a foo( = ) style call */ - symbol_c *MX_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (MX_param_value == NULL) - MX_param_value = function_call_param_iterator.next(); - symbol_c *MX_type_symbol = search_expression_type->get_type(MX_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(MX_type_symbol, last_type_symbol) ? search_expression_type->common_type(MX_type_symbol, last_type_symbol) : MX_type_symbol ; - - - { - - symbol_c * return_type_symbol = IN_type_symbol; - s4o.print("__limit_"); - IN_type_symbol->accept(*this); - s4o.print("("); - MN_param_value->accept(*this); - s4o.print(", "); - IN_param_value->accept(*this); - s4o.print(", "); - MX_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_limit*/ - break; - -/**** - *MUX - */ - case function_mux : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("K"); - /* Get the value from a foo( = ) style call */ - symbol_c *K_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (K_param_value == NULL) - K_param_value = function_call_param_iterator.next(); - symbol_c *K_type_symbol = search_expression_type->get_type(K_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(K_type_symbol, last_type_symbol) ? search_expression_type->common_type(K_type_symbol, last_type_symbol) : K_type_symbol ; - - if(search_expression_type->is_integer_type(K_type_symbol)) - { - - { - identifier_c param_name("IN0"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN0_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN0_param_value == NULL) - IN0_param_value = function_call_param_iterator.next(); - symbol_c *IN0_type_symbol = search_expression_type->get_type(IN0_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN0_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN0_type_symbol, last_type_symbol) : IN0_type_symbol ; - - - { - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - symbol_c * return_type_symbol = last_type_symbol; - s4o.indent_right(); - s4o.print("__mux_"); - return_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - K_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN0_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - - int base_num = 2; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mux*/ - break; - -/**** - *GT - */ - case function_gt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.indent_right(); - s4o.print("__gt_"); - last_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_gt*/ - break; - -/**** - *GE - */ - case function_ge : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.indent_right(); - s4o.print("__ge_"); - last_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_ge*/ - break; - -/**** - *EQ - */ - case function_eq : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.indent_right(); - s4o.print("__eq_"); - last_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_eq*/ - break; - -/**** - *LT - */ - case function_lt : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.indent_right(); - s4o.print("__lt_"); - last_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_lt*/ - break; - -/**** - *LE - */ - case function_le : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.indent_right(); - s4o.print("__le_"); - last_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_le*/ - break; - -/**** - *NE - */ - case function_ne : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - - { - - symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name; - s4o.indent_right(); - s4o.print("__ne_"); - last_type_symbol->accept(*this); - s4o.print("("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_ne*/ - break; - -/**** - *LEN - */ - case function_len : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("__len("); - IN_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - }/*function_len*/ - break; - -/**** - *LEFT - */ - case function_left : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("__left("); - IN_param_value->accept(*this); - s4o.print(", "); - L_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_left*/ - break; - -/**** - *RIGHT - */ - case function_right : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("__right("); - IN_param_value->accept(*this); - s4o.print(", "); - L_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_right*/ - break; - -/**** - *MID - */ - case function_mid : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("__mid("); - IN_param_value->accept(*this); - s4o.print(", "); - L_param_value->accept(*this); - s4o.print(", "); - P_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_mid*/ - break; - -/**** - *CONCAT - */ - case function_concat : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name; - s4o.print("__time_add("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.indent_right(); - s4o.print("__concat("); - s4o.print_integer(nb_param); - s4o.print(",\n" + s4o.indent_spaces); - IN1_param_value->accept(*this); - s4o.print(",\n" + s4o.indent_spaces); - IN2_param_value->accept(*this); - - int base_num = 3; - symbol_c *param_value = NULL; - do{ - char my_name[10]; - sprintf(my_name, "IN%d", base_num++); - identifier_c param_name(my_name); - - /* Get the value from a foo( = ) style call */ - param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (param_value == NULL) - param_value = function_call_param_iterator.next(); - if (param_value != NULL){ - symbol_c *current_type_symbol = search_expression_type->get_type(param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ; - - /*Function specific CODE */ - s4o.print(",\n" + s4o.indent_spaces); - param_value->accept(*this); - - } - - }while(param_value != NULL); - s4o.print(")"); - s4o.indent_left(); - return NULL; - - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_concat*/ - break; - -/**** - *INSERT - */ - case function_insert : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("__insert("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(", "); - P_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_insert*/ - break; - -/**** - *DELETE - */ - case function_delete : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN_param_value == NULL) - IN_param_value = function_call_param_iterator.next(); - symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("__delete("); - IN_param_value->accept(*this); - s4o.print(", "); - L_param_value->accept(*this); - s4o.print(", "); - P_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_delete*/ - break; - -/**** - *REPLACE - */ - case function_replace : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("L"); - /* Get the value from a foo( = ) style call */ - symbol_c *L_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (L_param_value == NULL) - L_param_value = function_call_param_iterator.next(); - symbol_c *L_type_symbol = search_expression_type->get_type(L_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(L_type_symbol, last_type_symbol) ? search_expression_type->common_type(L_type_symbol, last_type_symbol) : L_type_symbol ; - - if(search_expression_type->is_integer_type(L_type_symbol)) - { - - { - identifier_c param_name("P"); - /* Get the value from a foo( = ) style call */ - symbol_c *P_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (P_param_value == NULL) - P_param_value = function_call_param_iterator.next(); - symbol_c *P_type_symbol = search_expression_type->get_type(P_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(P_type_symbol, last_type_symbol) ? search_expression_type->common_type(P_type_symbol, last_type_symbol) : P_type_symbol ; - - if(search_expression_type->is_integer_type(P_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::string_type_name; - s4o.print("__replace("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(", "); - L_param_value->accept(*this); - s4o.print(", "); - P_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_replace*/ - break; - -/**** - *FIND - */ - case function_find : - { - symbol_c *last_type_symbol = NULL; - - { - identifier_c param_name("IN1"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN1_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN1_param_value == NULL) - IN1_param_value = function_call_param_iterator.next(); - symbol_c *IN1_type_symbol = search_expression_type->get_type(IN1_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN1_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN1_type_symbol, last_type_symbol) : IN1_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - { - identifier_c param_name("IN2"); - /* Get the value from a foo( = ) style call */ - symbol_c *IN2_param_value = function_call_param_iterator.search(¶m_name); - - /* Get the value from a foo() style call */ - if (IN2_param_value == NULL) - IN2_param_value = function_call_param_iterator.next(); - symbol_c *IN2_type_symbol = search_expression_type->get_type(IN2_param_value); - last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN2_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN2_type_symbol, last_type_symbol) : IN2_type_symbol ; - - if(search_expression_type->is_same_type(&search_constant_type_c::string_type_name, last_type_symbol)) - { - - symbol_c * return_type_symbol = &search_constant_type_c::int_type_name; - s4o.print("__find("); - IN1_param_value->accept(*this); - s4o.print(", "); - IN2_param_value->accept(*this); - s4o.print(")"); - return NULL; - - } - - ERROR; - } - - } - - ERROR; - } - - }/*function_find*/ - break; - - case function_none : - ERROR; -} -return NULL; diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/type_initial_value.cc --- a/stage4/generate_cc/type_initial_value.cc Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,378 +0,0 @@ -/* - * (c) 2003 Mario de Sousa - * - * 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) - * - */ - - -/* - * Determine the default initial value of a type declaration. - * - * This is part of the 4th stage that generates - * a c++ source program equivalent to the IL and ST - * code. - */ - - - - -//#include /* required for NULL */ -//#include -//#include - -//#include "../../util/symtable.hh" - -//#include "generate_cc.hh" - - - - - -/* Given a type definition declration, determine its default - * initial value. Note that types based on other types - * may have to iterate through each type it is based on - * to determine the initial value. - * E.g. - * TYPE - * A_t : INT := 10; - * B_t : A_t := 20; - * C_t : B_t; - * D_t : C_t := 40; - * END_TYPE - * Where the default initial value for C_t is 20! - */ -/* NOTE: The main program only needs one instance of - * this class of object. This class - * is therefore a singleton. - */ -class type_initial_value_c : public null_visitor_c { - private: - static type_initial_value_c *_instance; - /* constants for the default values of elementary data types... */ - static real_c *real_0; - static integer_c *integer_0, *integer_1; - static boolean_literal_c *bool_0; - static date_literal_c *date_literal_0; - static daytime_c *daytime_literal_0; - static duration_c *time_0; - static date_c *date_0; - static time_of_day_c *tod_0; - static date_and_time_c *dt_0; - static single_byte_character_string_c *string_0; - static double_byte_character_string_c *wstring_0; - - public: - static type_initial_value_c *instance(void) { - if (_instance != NULL) - return _instance; - - _instance = new type_initial_value_c; - - real_0 = new real_c("0"); - integer_0 = new integer_c("0"); - integer_1 = new integer_c("1"); - bool_0 = new boolean_literal_c(new bool_type_name_c(),new boolean_false_c()); - /* FIXME: Our current implementation only allows dates from 1970 onwards, - * but the standard defines the date 0001-01-01 as the default value - * for the DATE data type. Untill we fix our implementation, we use 1970-01-01 - * as our default value!! - */ -// date_literal_0 = new date_literal_c(integer_1, integer_1, integer_1); - date_literal_0 = new date_literal_c(new integer_c("1970"), integer_1, integer_1); - daytime_literal_0 = new daytime_c(integer_0, integer_0, real_0); - time_0 = new duration_c(NULL, new seconds_c(integer_0, NULL)); // T#0S - date_0 = new date_c(date_literal_0); // D#0001-01-01 - tod_0 = new time_of_day_c(daytime_literal_0); // TOD#00:00:00 - dt_0 = new date_and_time_c(date_literal_0, daytime_literal_0); // DT#0001-01-01-00:00:00 - string_0 = new single_byte_character_string_c("''"); - wstring_0 = new double_byte_character_string_c("\"\""); - - return _instance; - } - - protected: - type_initial_value_c(void) {} - - public: - symbol_c *get(identifier_c *type_name) { - TRACE("type_initial_value_c::get(): called "); - return (symbol_c *)type_name->accept(*this); - } - - - private: - void *handle_type_spec(symbol_c *base_type_name, symbol_c *type_spec_init) { - if (type_spec_init != NULL) - return type_spec_init; - /* no initial value specified, so we return - * the initial value of the type this type is based on... - */ - return base_type_name->accept(*this); - } - - public: - void *visit(identifier_c *type_name) { - /* look up the type declaration... */ - symbol_c *type_decl = type_symtable.find_value(type_name); - if (type_decl == type_symtable.end_value()) - /* Type declaration not found!! */ - /* NOTE: Variables declared out of function block 'data types', - * for eg: VAR timer: TON; END_VAR - * do not have a default value, so (TON) will never be found in the - * type symbol table. This means we cannot simply consider this - * an error and abort, but must rather return a NULL. - */ - return NULL; - - return type_decl->accept(*this); - } - -/***********************************/ -/* B 1.3.1 - Elementary Data Types */ -/***********************************/ - void *visit(time_type_name_c *symbol) {return (void *)time_0;} - void *visit(bool_type_name_c *symbol) {return (void *)bool_0;} - void *visit(sint_type_name_c *symbol) {return (void *)integer_0;} - void *visit(int_type_name_c *symbol) {return (void *)integer_0;} - void *visit(dint_type_name_c *symbol) {return (void *)integer_0;} - void *visit(lint_type_name_c *symbol) {return (void *)integer_0;} - void *visit(usint_type_name_c *symbol) {return (void *)integer_0;} - void *visit(uint_type_name_c *symbol) {return (void *)integer_0;} - void *visit(udint_type_name_c *symbol) {return (void *)integer_0;} - void *visit(ulint_type_name_c *symbol) {return (void *)integer_0;} - void *visit(real_type_name_c *symbol) {return (void *)real_0;} - void *visit(lreal_type_name_c *symbol) {return (void *)real_0;} - void *visit(date_type_name_c *symbol) {return (void *)date_0;} - void *visit(tod_type_name_c *symbol) {return (void *)tod_0;} - void *visit(dt_type_name_c *symbol) {return (void *)dt_0;} - void *visit(byte_type_name_c *symbol) {return (void *)integer_0;} - void *visit(word_type_name_c *symbol) {return (void *)integer_0;} - void *visit(dword_type_name_c *symbol) {return (void *)integer_0;} - void *visit(lword_type_name_c *symbol) {return (void *)integer_0;} - void *visit(string_type_name_c *symbol) {return (void *)string_0;} - void *visit(wstring_type_name_c *symbol) {return (void *)wstring_0;} - -/********************************/ -/* B 1.3.3 - Derived data types */ -/********************************/ -/* simple_type_name ':' simple_spec_init */ - void *visit(simple_type_declaration_c *symbol) { - return symbol->simple_spec_init->accept(*this); - } -/* simple_specification ASSIGN constant */ - void *visit(simple_spec_init_c *symbol) { - return handle_type_spec(symbol->simple_specification, symbol->constant); - } -/* subrange_type_name ':' subrange_spec_init */ - void *visit(subrange_type_declaration_c *symbol) { - return symbol->subrange_spec_init->accept(*this); - } -/* subrange_specification ASSIGN signed_integer */ - void *visit(subrange_spec_init_c *symbol) { - return handle_type_spec(symbol->subrange_specification, symbol->signed_integer); - } -/* integer_type_name '(' subrange')' */ - void *visit(subrange_specification_c *symbol) { - /* if no initial value explicitly given, then use the lowest value of the subrange */ - return symbol->subrange->accept(*this); - } -/* signed_integer DOTDOT signed_integer */ - void *visit(subrange_c *symbol) {return symbol->lower_limit;} -/* enumerated_type_name ':' enumerated_spec_init */ - void *visit(enumerated_type_declaration_c *symbol) { - return symbol->enumerated_spec_init->accept(*this); - } -/* enumerated_specification ASSIGN enumerated_value */ - void *visit(enumerated_spec_init_c *symbol) { - return handle_type_spec(symbol->enumerated_specification, symbol->enumerated_value); - } -/* helper symbol for enumerated_specification->enumerated_spec_init */ -/* enumerated_value_list ',' enumerated_value */ - void *visit(enumerated_value_list_c *symbol) { - /* if no initial value explicitly given, then use the lowest value of the subrange */ - return (void *)symbol->elements[0]; - } -/* enumerated_type_name '#' identifier */ -// SYM_REF2(enumerated_value_c, type, value) - void *visit(enumerated_value_c *symbol) {ERROR; return NULL;} -/* identifier ':' array_spec_init */ - void *visit(array_type_declaration_c *symbol) { - return symbol->array_spec_init->accept(*this); - } -/* array_specification [ASSIGN array_initialization} */ -/* array_initialization may be NULL ! */ - void *visit(array_spec_init_c *symbol) { - return handle_type_spec(symbol->array_specification, symbol->array_initialization); - } -/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */ - void *visit(array_specification_c *symbol) { - symbol_c *init_value = (symbol_c *)symbol->non_generic_type_name->accept(*this); - - /* Now build a array_initial_elements_list_c list, and populate it - * with 1 element of the array_initial_elements_c class - */ - /* The array_initial_elements_c will contain a reference to the init_value, - * and another constant representing the number of elements in the array. - * In essence, we are building the equivilant of the following ST/IL code: - * New_array_t : ARRAY [1..30, 51..60] of INT := [40(XXX)]; - * from the user given code - * New_array_t : ARRAY [1..30, 51..60] of INT; - * and replacing XXX with the default initial value of INT. - */ - /* now we need to determine the number of elements in the array... */ - /* Easier said than done, as the array may have a list of subranges, as in the - * example given above!! - */ - /* TODO !!!!!*/ - /* For now, just assume an array with 1 element. - * I (Mario) want to finish off this part of the code before getting boged down - * in something else... - */ - // NOTE: We are leaking memory, as the integer will never get free'd!! - integer_c *integer = new integer_c("1"); - // NOTE: We are leaking memory, as the array_initial_elements will never get free'd!! - array_initial_elements_c *array_initial_elements = new array_initial_elements_c(integer, init_value); - // NOTE: We are leaking memory, as the array_initial_elements_list will never get free'd!! - array_initial_elements_list_c *array_initial_elements_list = new array_initial_elements_list_c(); - array_initial_elements_list->add_element(array_initial_elements); - return (void *)array_initial_elements_list; - } -/* helper symbol for array_specification */ -/* array_subrange_list ',' subrange */ - void *visit(array_subrange_list_c *symbol) {ERROR; return NULL;} -/* array_initialization: '[' array_initial_elements_list ']' */ -/* helper symbol for array_initialization */ -/* array_initial_elements_list ',' array_initial_elements */ - void *visit(array_initial_elements_list_c *symbol) {ERROR; return NULL;} -/* integer '(' [array_initial_element] ')' */ -/* array_initial_element may be NULL ! */ - void *visit(array_initial_elements_c *symbol) {ERROR; return NULL;} - - - - /* TODO: from this point forward... */ - -/* structure_type_name ':' structure_specification */ - void *visit(structure_type_declaration_c *symbol) {return NULL;} -/* structure_type_name ASSIGN structure_initialization */ -/* structure_initialization may be NULL ! */ - void *visit(initialized_structure_c *symbol) {return NULL;} -/* helper symbol for structure_declaration */ -/* structure_declaration: STRUCT structure_element_declaration_list END_STRUCT */ -/* structure_element_declaration_list structure_element_declaration ';' */ - void *visit(structure_element_declaration_list_c *symbol) {return NULL;} -/* structure_element_name ':' *_spec_init */ - void *visit(structure_element_declaration_c *symbol) {return NULL;} -/* helper symbol for structure_initialization */ -/* structure_initialization: '(' structure_element_initialization_list ')' */ -/* structure_element_initialization_list ',' structure_element_initialization */ - void *visit(structure_element_initialization_list_c *symbol) {return NULL;} -/* structure_element_name ASSIGN value */ - void *visit(structure_element_initialization_c *symbol) {return NULL;} -/* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ -/* - * NOTE: - * (Summary: Contrary to what is expected, the - * string_type_declaration_c is not used to store - * simple string type declarations that do not include - * size limits. - * For e.g.: - * str1_type: STRING := "hello!" - * will be stored in a simple_type_declaration_c - * instead of a string_type_declaration_c. - * The following: - * str2_type: STRING [64] := "hello!" - * will be stored in a sring_type_declaration_c - * - * Read on for why this is done... - * End Summary) - * - * According to the spec, the valid construct - * TYPE new_str_type : STRING := "hello!"; END_TYPE - * has two possible routes to type_declaration... - * - * Route 1: - * type_declaration: single_element_type_declaration - * single_element_type_declaration: simple_type_declaration - * simple_type_declaration: identifier ':' simple_spec_init - * simple_spec_init: simple_specification ASSIGN constant - * (shift: identifier <- 'new_str_type') - * simple_specification: elementary_type_name - * elementary_type_name: STRING - * (shift: elementary_type_name <- STRING) - * (reduce: simple_specification <- elementary_type_name) - * (shift: constant <- "hello!") - * (reduce: simple_spec_init: simple_specification ASSIGN constant) - * (reduce: ...) - * - * - * Route 2: - * type_declaration: string_type_declaration - * string_type_declaration: identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init - * (shift: identifier <- 'new_str_type') - * elementary_string_type_name: STRING - * (shift: elementary_string_type_name <- STRING) - * (shift: string_type_declaration_size <- empty ) - * string_type_declaration_init: ASSIGN character_string - * (shift: character_string <- "hello!") - * (reduce: string_type_declaration_init <- ASSIGN character_string) - * (reduce: string_type_declaration <- identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init ) - * (reduce: type_declaration <- string_type_declaration) - * - * - * At first glance it seems that removing route 1 would make - * the most sense. Unfortunately the construct 'simple_spec_init' - * shows up multiple times in other rules, so changing this construct - * would also mean changing all the rules in which it appears. - * I (Mario) therefore chose to remove route 2 instead. This means - * that the above declaration gets stored in a - * simple_type_declaration_c, and not in a string_type_declaration_c - * as would be expected! - */ -/* string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */ -#if 0 -SYM_REF4(string_type_declaration_c, string_type_name, - elementary_string_type_name, - string_type_declaration_size, - string_type_declaration_init) /* may be == NULL! */ -#endif - void *visit(string_type_declaration_c *symbol) {return NULL;} -}; - -type_initial_value_c *type_initial_value_c::_instance = NULL; -real_c *type_initial_value_c::real_0 = NULL; -integer_c *type_initial_value_c::integer_0 = NULL; -integer_c *type_initial_value_c::integer_1 = NULL; -boolean_literal_c *type_initial_value_c::bool_0 = NULL; -date_literal_c *type_initial_value_c::date_literal_0 = NULL; -daytime_c *type_initial_value_c::daytime_literal_0 = NULL; -duration_c *type_initial_value_c::time_0 = NULL; -date_c *type_initial_value_c::date_0 = NULL; -time_of_day_c *type_initial_value_c::tod_0 = NULL; -date_and_time_c *type_initial_value_c::dt_0 = NULL; -single_byte_character_string_c *type_initial_value_c::string_0 = NULL; -double_byte_character_string_c *type_initial_value_c::wstring_0 = NULL; - - - - - - diff -r 41cb5b80416e -r e1f0ebd2d9ec stage4/generate_cc/types.h --- a/stage4/generate_cc/types.h Tue Oct 23 10:35:58 2007 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,73 +0,0 @@ -/* - * (c) 2000 Jiri Baum - * Mario de Sousa - * - * 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. - */ - - -#ifndef __PLC_TYPES_H -#define __PLC_TYPES_H - -#include -#include /* some limits related to floats are located here (?) */ - - -/* - * This will need to be conditional on the arquitecture or something. - * Anyone know where we can snarf the relevant magic easily? - */ -typedef double f64; /* 64-bit floating point */ -typedef float f32; /* 32-bit floating point */ - -typedef unsigned long long int u64; /* 64-bit unsigned integer */ -typedef long long int i64; /* 64-bit signed integer */ -typedef unsigned int u32; /* 32-bit unsigned integer */ -typedef int i32; /* 32-bit signed integer */ -typedef unsigned short int u16; /* 16-bit unsigned integer */ -typedef short int i16; /* 16-bit signed integer */ -typedef unsigned char u8; /* 8-bit unsigned integer */ -typedef signed char i8; /* 8-bit signed integer */ - -/* some platforms seem to be missing with the definition of FLT_MAX */ -#ifndef FLT_MAX - /* this is the minimum value guaranteed by ANSI C++ */ - /* does anybody know the minimum value guaranteed for ANSI C ? */ -#define FLT_MAX 1E+37 -#endif -#ifndef FLT_MIN - /* this is the minimum value guaranteed by ANSI C++ */ - /* does anybody know the minimum value guaranteed for ANSI C ? */ -#define FLT_MIN 1E-37 -#endif - -#define f32_MAX FLT_MAX -#define f32_MIN FLT_MIN - -#define u32_MAX UINT_MAX -#define u32_MIN 0 -#define i32_MAX INT_MAX -#define i32_MIN INT_MIN - -#define u16_MAX USHRT_MAX -#define u16_MIN 0 -#define i16_MAX SHRT_MAX -#define i16_MIN SHRT_MIN - -#define u8_MAX UCHAR_MAX -#define u8_MIN 0 -#define i8_MAX SCHAR_MAX -#define i8_MIN SCHAR_MIN - -#endif /* __PLC_TYPES_H */ -