--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/stage4/generate_cc/function_type_decl.h	Mon Jun 18 14:45:03 2007 +0200
@@ -0,0 +1,514 @@
+
+/****
+ * IEC 61131-3 standard function lib
+ * generated code, do not edit by hand
+ */
+typedef enum {
+	function_real_to_real,
+	function_real_to_sint,
+	function_real_to_lint,
+	function_real_to_dint,
+	function_real_to_date,
+	function_real_to_dword,
+	function_real_to_dt,
+	function_real_to_tod,
+	function_real_to_udint,
+	function_real_to_word,
+	function_real_to_wstring,
+	function_real_to_string,
+	function_real_to_lword,
+	function_real_to_uint,
+	function_real_to_lreal,
+	function_real_to_byte,
+	function_real_to_usint,
+	function_real_to_ulint,
+	function_real_to_bool,
+	function_real_to_time,
+	function_real_to_int,
+	function_sint_to_real,
+	function_sint_to_sint,
+	function_sint_to_lint,
+	function_sint_to_dint,
+	function_sint_to_date,
+	function_sint_to_dword,
+	function_sint_to_dt,
+	function_sint_to_tod,
+	function_sint_to_udint,
+	function_sint_to_word,
+	function_sint_to_wstring,
+	function_sint_to_string,
+	function_sint_to_lword,
+	function_sint_to_uint,
+	function_sint_to_lreal,
+	function_sint_to_byte,
+	function_sint_to_usint,
+	function_sint_to_ulint,
+	function_sint_to_bool,
+	function_sint_to_time,
+	function_sint_to_int,
+	function_lint_to_real,
+	function_lint_to_sint,
+	function_lint_to_lint,
+	function_lint_to_dint,
+	function_lint_to_date,
+	function_lint_to_dword,
+	function_lint_to_dt,
+	function_lint_to_tod,
+	function_lint_to_udint,
+	function_lint_to_word,
+	function_lint_to_wstring,
+	function_lint_to_string,
+	function_lint_to_lword,
+	function_lint_to_uint,
+	function_lint_to_lreal,
+	function_lint_to_byte,
+	function_lint_to_usint,
+	function_lint_to_ulint,
+	function_lint_to_bool,
+	function_lint_to_time,
+	function_lint_to_int,
+	function_dint_to_real,
+	function_dint_to_sint,
+	function_dint_to_lint,
+	function_dint_to_dint,
+	function_dint_to_date,
+	function_dint_to_dword,
+	function_dint_to_dt,
+	function_dint_to_tod,
+	function_dint_to_udint,
+	function_dint_to_word,
+	function_dint_to_wstring,
+	function_dint_to_string,
+	function_dint_to_lword,
+	function_dint_to_uint,
+	function_dint_to_lreal,
+	function_dint_to_byte,
+	function_dint_to_usint,
+	function_dint_to_ulint,
+	function_dint_to_bool,
+	function_dint_to_time,
+	function_dint_to_int,
+	function_date_to_real,
+	function_date_to_sint,
+	function_date_to_lint,
+	function_date_to_dint,
+	function_date_to_date,
+	function_date_to_dword,
+	function_date_to_dt,
+	function_date_to_tod,
+	function_date_to_udint,
+	function_date_to_word,
+	function_date_to_wstring,
+	function_date_to_string,
+	function_date_to_lword,
+	function_date_to_uint,
+	function_date_to_lreal,
+	function_date_to_byte,
+	function_date_to_usint,
+	function_date_to_ulint,
+	function_date_to_bool,
+	function_date_to_time,
+	function_date_to_int,
+	function_dword_to_real,
+	function_dword_to_sint,
+	function_dword_to_lint,
+	function_dword_to_dint,
+	function_dword_to_date,
+	function_dword_to_dword,
+	function_dword_to_dt,
+	function_dword_to_tod,
+	function_dword_to_udint,
+	function_dword_to_word,
+	function_dword_to_wstring,
+	function_dword_to_string,
+	function_dword_to_lword,
+	function_dword_to_uint,
+	function_dword_to_lreal,
+	function_dword_to_byte,
+	function_dword_to_usint,
+	function_dword_to_ulint,
+	function_dword_to_bool,
+	function_dword_to_time,
+	function_dword_to_int,
+	function_dt_to_real,
+	function_dt_to_sint,
+	function_dt_to_lint,
+	function_dt_to_dint,
+	function_dt_to_date,
+	function_dt_to_dword,
+	function_dt_to_dt,
+	function_dt_to_tod,
+	function_dt_to_udint,
+	function_dt_to_word,
+	function_dt_to_wstring,
+	function_dt_to_string,
+	function_dt_to_lword,
+	function_dt_to_uint,
+	function_dt_to_lreal,
+	function_dt_to_byte,
+	function_dt_to_usint,
+	function_dt_to_ulint,
+	function_dt_to_bool,
+	function_dt_to_time,
+	function_dt_to_int,
+	function_tod_to_real,
+	function_tod_to_sint,
+	function_tod_to_lint,
+	function_tod_to_dint,
+	function_tod_to_date,
+	function_tod_to_dword,
+	function_tod_to_dt,
+	function_tod_to_tod,
+	function_tod_to_udint,
+	function_tod_to_word,
+	function_tod_to_wstring,
+	function_tod_to_string,
+	function_tod_to_lword,
+	function_tod_to_uint,
+	function_tod_to_lreal,
+	function_tod_to_byte,
+	function_tod_to_usint,
+	function_tod_to_ulint,
+	function_tod_to_bool,
+	function_tod_to_time,
+	function_tod_to_int,
+	function_udint_to_real,
+	function_udint_to_sint,
+	function_udint_to_lint,
+	function_udint_to_dint,
+	function_udint_to_date,
+	function_udint_to_dword,
+	function_udint_to_dt,
+	function_udint_to_tod,
+	function_udint_to_udint,
+	function_udint_to_word,
+	function_udint_to_wstring,
+	function_udint_to_string,
+	function_udint_to_lword,
+	function_udint_to_uint,
+	function_udint_to_lreal,
+	function_udint_to_byte,
+	function_udint_to_usint,
+	function_udint_to_ulint,
+	function_udint_to_bool,
+	function_udint_to_time,
+	function_udint_to_int,
+	function_word_to_real,
+	function_word_to_sint,
+	function_word_to_lint,
+	function_word_to_dint,
+	function_word_to_date,
+	function_word_to_dword,
+	function_word_to_dt,
+	function_word_to_tod,
+	function_word_to_udint,
+	function_word_to_word,
+	function_word_to_wstring,
+	function_word_to_string,
+	function_word_to_lword,
+	function_word_to_uint,
+	function_word_to_lreal,
+	function_word_to_byte,
+	function_word_to_usint,
+	function_word_to_ulint,
+	function_word_to_bool,
+	function_word_to_time,
+	function_word_to_int,
+	function_wstring_to_real,
+	function_wstring_to_sint,
+	function_wstring_to_lint,
+	function_wstring_to_dint,
+	function_wstring_to_date,
+	function_wstring_to_dword,
+	function_wstring_to_dt,
+	function_wstring_to_tod,
+	function_wstring_to_udint,
+	function_wstring_to_word,
+	function_wstring_to_wstring,
+	function_wstring_to_string,
+	function_wstring_to_lword,
+	function_wstring_to_uint,
+	function_wstring_to_lreal,
+	function_wstring_to_byte,
+	function_wstring_to_usint,
+	function_wstring_to_ulint,
+	function_wstring_to_bool,
+	function_wstring_to_time,
+	function_wstring_to_int,
+	function_string_to_real,
+	function_string_to_sint,
+	function_string_to_lint,
+	function_string_to_dint,
+	function_string_to_date,
+	function_string_to_dword,
+	function_string_to_dt,
+	function_string_to_tod,
+	function_string_to_udint,
+	function_string_to_word,
+	function_string_to_wstring,
+	function_string_to_string,
+	function_string_to_lword,
+	function_string_to_uint,
+	function_string_to_lreal,
+	function_string_to_byte,
+	function_string_to_usint,
+	function_string_to_ulint,
+	function_string_to_bool,
+	function_string_to_time,
+	function_string_to_int,
+	function_lword_to_real,
+	function_lword_to_sint,
+	function_lword_to_lint,
+	function_lword_to_dint,
+	function_lword_to_date,
+	function_lword_to_dword,
+	function_lword_to_dt,
+	function_lword_to_tod,
+	function_lword_to_udint,
+	function_lword_to_word,
+	function_lword_to_wstring,
+	function_lword_to_string,
+	function_lword_to_lword,
+	function_lword_to_uint,
+	function_lword_to_lreal,
+	function_lword_to_byte,
+	function_lword_to_usint,
+	function_lword_to_ulint,
+	function_lword_to_bool,
+	function_lword_to_time,
+	function_lword_to_int,
+	function_uint_to_real,
+	function_uint_to_sint,
+	function_uint_to_lint,
+	function_uint_to_dint,
+	function_uint_to_date,
+	function_uint_to_dword,
+	function_uint_to_dt,
+	function_uint_to_tod,
+	function_uint_to_udint,
+	function_uint_to_word,
+	function_uint_to_wstring,
+	function_uint_to_string,
+	function_uint_to_lword,
+	function_uint_to_uint,
+	function_uint_to_lreal,
+	function_uint_to_byte,
+	function_uint_to_usint,
+	function_uint_to_ulint,
+	function_uint_to_bool,
+	function_uint_to_time,
+	function_uint_to_int,
+	function_lreal_to_real,
+	function_lreal_to_sint,
+	function_lreal_to_lint,
+	function_lreal_to_dint,
+	function_lreal_to_date,
+	function_lreal_to_dword,
+	function_lreal_to_dt,
+	function_lreal_to_tod,
+	function_lreal_to_udint,
+	function_lreal_to_word,
+	function_lreal_to_wstring,
+	function_lreal_to_string,
+	function_lreal_to_lword,
+	function_lreal_to_uint,
+	function_lreal_to_lreal,
+	function_lreal_to_byte,
+	function_lreal_to_usint,
+	function_lreal_to_ulint,
+	function_lreal_to_bool,
+	function_lreal_to_time,
+	function_lreal_to_int,
+	function_byte_to_real,
+	function_byte_to_sint,
+	function_byte_to_lint,
+	function_byte_to_dint,
+	function_byte_to_date,
+	function_byte_to_dword,
+	function_byte_to_dt,
+	function_byte_to_tod,
+	function_byte_to_udint,
+	function_byte_to_word,
+	function_byte_to_wstring,
+	function_byte_to_string,
+	function_byte_to_lword,
+	function_byte_to_uint,
+	function_byte_to_lreal,
+	function_byte_to_byte,
+	function_byte_to_usint,
+	function_byte_to_ulint,
+	function_byte_to_bool,
+	function_byte_to_time,
+	function_byte_to_int,
+	function_usint_to_real,
+	function_usint_to_sint,
+	function_usint_to_lint,
+	function_usint_to_dint,
+	function_usint_to_date,
+	function_usint_to_dword,
+	function_usint_to_dt,
+	function_usint_to_tod,
+	function_usint_to_udint,
+	function_usint_to_word,
+	function_usint_to_wstring,
+	function_usint_to_string,
+	function_usint_to_lword,
+	function_usint_to_uint,
+	function_usint_to_lreal,
+	function_usint_to_byte,
+	function_usint_to_usint,
+	function_usint_to_ulint,
+	function_usint_to_bool,
+	function_usint_to_time,
+	function_usint_to_int,
+	function_ulint_to_real,
+	function_ulint_to_sint,
+	function_ulint_to_lint,
+	function_ulint_to_dint,
+	function_ulint_to_date,
+	function_ulint_to_dword,
+	function_ulint_to_dt,
+	function_ulint_to_tod,
+	function_ulint_to_udint,
+	function_ulint_to_word,
+	function_ulint_to_wstring,
+	function_ulint_to_string,
+	function_ulint_to_lword,
+	function_ulint_to_uint,
+	function_ulint_to_lreal,
+	function_ulint_to_byte,
+	function_ulint_to_usint,
+	function_ulint_to_ulint,
+	function_ulint_to_bool,
+	function_ulint_to_time,
+	function_ulint_to_int,
+	function_bool_to_real,
+	function_bool_to_sint,
+	function_bool_to_lint,
+	function_bool_to_dint,
+	function_bool_to_date,
+	function_bool_to_dword,
+	function_bool_to_dt,
+	function_bool_to_tod,
+	function_bool_to_udint,
+	function_bool_to_word,
+	function_bool_to_wstring,
+	function_bool_to_string,
+	function_bool_to_lword,
+	function_bool_to_uint,
+	function_bool_to_lreal,
+	function_bool_to_byte,
+	function_bool_to_usint,
+	function_bool_to_ulint,
+	function_bool_to_bool,
+	function_bool_to_time,
+	function_bool_to_int,
+	function_time_to_real,
+	function_time_to_sint,
+	function_time_to_lint,
+	function_time_to_dint,
+	function_time_to_date,
+	function_time_to_dword,
+	function_time_to_dt,
+	function_time_to_tod,
+	function_time_to_udint,
+	function_time_to_word,
+	function_time_to_wstring,
+	function_time_to_string,
+	function_time_to_lword,
+	function_time_to_uint,
+	function_time_to_lreal,
+	function_time_to_byte,
+	function_time_to_usint,
+	function_time_to_ulint,
+	function_time_to_bool,
+	function_time_to_time,
+	function_time_to_int,
+	function_int_to_real,
+	function_int_to_sint,
+	function_int_to_lint,
+	function_int_to_dint,
+	function_int_to_date,
+	function_int_to_dword,
+	function_int_to_dt,
+	function_int_to_tod,
+	function_int_to_udint,
+	function_int_to_word,
+	function_int_to_wstring,
+	function_int_to_string,
+	function_int_to_lword,
+	function_int_to_uint,
+	function_int_to_lreal,
+	function_int_to_byte,
+	function_int_to_usint,
+	function_int_to_ulint,
+	function_int_to_bool,
+	function_int_to_time,
+	function_int_to_int,
+	function_trunc,
+	function_bcd_to_sint,
+	function_bcd_to_lint,
+	function_bcd_to_dint,
+	function_bcd_to_udint,
+	function_bcd_to_uint,
+	function_bcd_to_usint,
+	function_bcd_to_ulint,
+	function_bcd_to_int,
+	function_sint_to_bcd,
+	function_lint_to_bcd,
+	function_dint_to_bcd,
+	function_udint_to_bcd,
+	function_uint_to_bcd,
+	function_usint_to_bcd,
+	function_ulint_to_bcd,
+	function_int_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;

--- a/stage4/generate_cc/generate_cc_st.cc	Thu Jun 14 08:58:10 2007 +0200
+++ b/stage4/generate_cc/generate_cc_st.cc	Mon Jun 18 14:45:03 2007 +0200
@@ -351,6 +351,10 @@
     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) {
@@ -455,6 +459,7 @@
         default: ERROR;
       }
     } /* for(...) */
+#endif
   }
   else {
     /* loop through each function parameter, find the value we should pass

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/stage4/generate_cc/get_function_type_decl.c	Mon Jun 18 14:45:03 2007 +0200
@@ -0,0 +1,1528 @@
+
+/****
+ * 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, "REAL_TO_REAL"))
+		return function_real_to_real;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_SINT"))
+		return function_real_to_sint;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_LINT"))
+		return function_real_to_lint;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_DINT"))
+		return function_real_to_dint;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_DATE"))
+		return function_real_to_date;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_DWORD"))
+		return function_real_to_dword;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_DT"))
+		return function_real_to_dt;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_TOD"))
+		return function_real_to_tod;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_UDINT"))
+		return function_real_to_udint;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_WORD"))
+		return function_real_to_word;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_WSTRING"))
+		return function_real_to_wstring;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_STRING"))
+		return function_real_to_string;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_LWORD"))
+		return function_real_to_lword;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_UINT"))
+		return function_real_to_uint;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_LREAL"))
+		return function_real_to_lreal;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_BYTE"))
+		return function_real_to_byte;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_USINT"))
+		return function_real_to_usint;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_ULINT"))
+		return function_real_to_ulint;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_BOOL"))
+		return function_real_to_bool;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_TIME"))
+		return function_real_to_time;
+
+	if (!strcasecmp(function_name->value, "REAL_TO_INT"))
+		return function_real_to_int;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_REAL"))
+		return function_sint_to_real;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_SINT"))
+		return function_sint_to_sint;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_LINT"))
+		return function_sint_to_lint;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_DINT"))
+		return function_sint_to_dint;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_DATE"))
+		return function_sint_to_date;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_DWORD"))
+		return function_sint_to_dword;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_DT"))
+		return function_sint_to_dt;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_TOD"))
+		return function_sint_to_tod;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_UDINT"))
+		return function_sint_to_udint;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_WORD"))
+		return function_sint_to_word;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_WSTRING"))
+		return function_sint_to_wstring;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_STRING"))
+		return function_sint_to_string;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_LWORD"))
+		return function_sint_to_lword;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_UINT"))
+		return function_sint_to_uint;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_LREAL"))
+		return function_sint_to_lreal;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_BYTE"))
+		return function_sint_to_byte;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_USINT"))
+		return function_sint_to_usint;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_ULINT"))
+		return function_sint_to_ulint;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_BOOL"))
+		return function_sint_to_bool;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_TIME"))
+		return function_sint_to_time;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_INT"))
+		return function_sint_to_int;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_REAL"))
+		return function_lint_to_real;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_SINT"))
+		return function_lint_to_sint;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_LINT"))
+		return function_lint_to_lint;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_DINT"))
+		return function_lint_to_dint;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_DATE"))
+		return function_lint_to_date;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_DWORD"))
+		return function_lint_to_dword;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_DT"))
+		return function_lint_to_dt;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_TOD"))
+		return function_lint_to_tod;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_UDINT"))
+		return function_lint_to_udint;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_WORD"))
+		return function_lint_to_word;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_WSTRING"))
+		return function_lint_to_wstring;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_STRING"))
+		return function_lint_to_string;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_LWORD"))
+		return function_lint_to_lword;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_UINT"))
+		return function_lint_to_uint;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_LREAL"))
+		return function_lint_to_lreal;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_BYTE"))
+		return function_lint_to_byte;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_USINT"))
+		return function_lint_to_usint;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_ULINT"))
+		return function_lint_to_ulint;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_BOOL"))
+		return function_lint_to_bool;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_TIME"))
+		return function_lint_to_time;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_INT"))
+		return function_lint_to_int;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_REAL"))
+		return function_dint_to_real;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_SINT"))
+		return function_dint_to_sint;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_LINT"))
+		return function_dint_to_lint;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_DINT"))
+		return function_dint_to_dint;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_DATE"))
+		return function_dint_to_date;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_DWORD"))
+		return function_dint_to_dword;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_DT"))
+		return function_dint_to_dt;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_TOD"))
+		return function_dint_to_tod;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_UDINT"))
+		return function_dint_to_udint;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_WORD"))
+		return function_dint_to_word;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_WSTRING"))
+		return function_dint_to_wstring;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_STRING"))
+		return function_dint_to_string;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_LWORD"))
+		return function_dint_to_lword;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_UINT"))
+		return function_dint_to_uint;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_LREAL"))
+		return function_dint_to_lreal;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_BYTE"))
+		return function_dint_to_byte;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_USINT"))
+		return function_dint_to_usint;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_ULINT"))
+		return function_dint_to_ulint;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_BOOL"))
+		return function_dint_to_bool;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_TIME"))
+		return function_dint_to_time;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_INT"))
+		return function_dint_to_int;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_REAL"))
+		return function_date_to_real;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_SINT"))
+		return function_date_to_sint;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_LINT"))
+		return function_date_to_lint;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_DINT"))
+		return function_date_to_dint;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_DATE"))
+		return function_date_to_date;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_DWORD"))
+		return function_date_to_dword;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_DT"))
+		return function_date_to_dt;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_TOD"))
+		return function_date_to_tod;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_UDINT"))
+		return function_date_to_udint;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_WORD"))
+		return function_date_to_word;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_WSTRING"))
+		return function_date_to_wstring;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_STRING"))
+		return function_date_to_string;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_LWORD"))
+		return function_date_to_lword;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_UINT"))
+		return function_date_to_uint;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_LREAL"))
+		return function_date_to_lreal;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_BYTE"))
+		return function_date_to_byte;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_USINT"))
+		return function_date_to_usint;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_ULINT"))
+		return function_date_to_ulint;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_BOOL"))
+		return function_date_to_bool;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_TIME"))
+		return function_date_to_time;
+
+	if (!strcasecmp(function_name->value, "DATE_TO_INT"))
+		return function_date_to_int;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_REAL"))
+		return function_dword_to_real;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_SINT"))
+		return function_dword_to_sint;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_LINT"))
+		return function_dword_to_lint;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_DINT"))
+		return function_dword_to_dint;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_DATE"))
+		return function_dword_to_date;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_DWORD"))
+		return function_dword_to_dword;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_DT"))
+		return function_dword_to_dt;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_TOD"))
+		return function_dword_to_tod;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_UDINT"))
+		return function_dword_to_udint;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_WORD"))
+		return function_dword_to_word;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_WSTRING"))
+		return function_dword_to_wstring;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_STRING"))
+		return function_dword_to_string;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_LWORD"))
+		return function_dword_to_lword;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_UINT"))
+		return function_dword_to_uint;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_LREAL"))
+		return function_dword_to_lreal;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_BYTE"))
+		return function_dword_to_byte;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_USINT"))
+		return function_dword_to_usint;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_ULINT"))
+		return function_dword_to_ulint;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_BOOL"))
+		return function_dword_to_bool;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_TIME"))
+		return function_dword_to_time;
+
+	if (!strcasecmp(function_name->value, "DWORD_TO_INT"))
+		return function_dword_to_int;
+
+	if (!strcasecmp(function_name->value, "DT_TO_REAL"))
+		return function_dt_to_real;
+
+	if (!strcasecmp(function_name->value, "DT_TO_SINT"))
+		return function_dt_to_sint;
+
+	if (!strcasecmp(function_name->value, "DT_TO_LINT"))
+		return function_dt_to_lint;
+
+	if (!strcasecmp(function_name->value, "DT_TO_DINT"))
+		return function_dt_to_dint;
+
+	if (!strcasecmp(function_name->value, "DT_TO_DATE"))
+		return function_dt_to_date;
+
+	if (!strcasecmp(function_name->value, "DT_TO_DWORD"))
+		return function_dt_to_dword;
+
+	if (!strcasecmp(function_name->value, "DT_TO_DT"))
+		return function_dt_to_dt;
+
+	if (!strcasecmp(function_name->value, "DT_TO_TOD"))
+		return function_dt_to_tod;
+
+	if (!strcasecmp(function_name->value, "DT_TO_UDINT"))
+		return function_dt_to_udint;
+
+	if (!strcasecmp(function_name->value, "DT_TO_WORD"))
+		return function_dt_to_word;
+
+	if (!strcasecmp(function_name->value, "DT_TO_WSTRING"))
+		return function_dt_to_wstring;
+
+	if (!strcasecmp(function_name->value, "DT_TO_STRING"))
+		return function_dt_to_string;
+
+	if (!strcasecmp(function_name->value, "DT_TO_LWORD"))
+		return function_dt_to_lword;
+
+	if (!strcasecmp(function_name->value, "DT_TO_UINT"))
+		return function_dt_to_uint;
+
+	if (!strcasecmp(function_name->value, "DT_TO_LREAL"))
+		return function_dt_to_lreal;
+
+	if (!strcasecmp(function_name->value, "DT_TO_BYTE"))
+		return function_dt_to_byte;
+
+	if (!strcasecmp(function_name->value, "DT_TO_USINT"))
+		return function_dt_to_usint;
+
+	if (!strcasecmp(function_name->value, "DT_TO_ULINT"))
+		return function_dt_to_ulint;
+
+	if (!strcasecmp(function_name->value, "DT_TO_BOOL"))
+		return function_dt_to_bool;
+
+	if (!strcasecmp(function_name->value, "DT_TO_TIME"))
+		return function_dt_to_time;
+
+	if (!strcasecmp(function_name->value, "DT_TO_INT"))
+		return function_dt_to_int;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_REAL"))
+		return function_tod_to_real;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_SINT"))
+		return function_tod_to_sint;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_LINT"))
+		return function_tod_to_lint;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_DINT"))
+		return function_tod_to_dint;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_DATE"))
+		return function_tod_to_date;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_DWORD"))
+		return function_tod_to_dword;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_DT"))
+		return function_tod_to_dt;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_TOD"))
+		return function_tod_to_tod;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_UDINT"))
+		return function_tod_to_udint;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_WORD"))
+		return function_tod_to_word;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_WSTRING"))
+		return function_tod_to_wstring;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_STRING"))
+		return function_tod_to_string;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_LWORD"))
+		return function_tod_to_lword;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_UINT"))
+		return function_tod_to_uint;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_LREAL"))
+		return function_tod_to_lreal;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_BYTE"))
+		return function_tod_to_byte;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_USINT"))
+		return function_tod_to_usint;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_ULINT"))
+		return function_tod_to_ulint;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_BOOL"))
+		return function_tod_to_bool;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_TIME"))
+		return function_tod_to_time;
+
+	if (!strcasecmp(function_name->value, "TOD_TO_INT"))
+		return function_tod_to_int;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_REAL"))
+		return function_udint_to_real;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_SINT"))
+		return function_udint_to_sint;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_LINT"))
+		return function_udint_to_lint;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_DINT"))
+		return function_udint_to_dint;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_DATE"))
+		return function_udint_to_date;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_DWORD"))
+		return function_udint_to_dword;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_DT"))
+		return function_udint_to_dt;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_TOD"))
+		return function_udint_to_tod;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_UDINT"))
+		return function_udint_to_udint;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_WORD"))
+		return function_udint_to_word;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_WSTRING"))
+		return function_udint_to_wstring;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_STRING"))
+		return function_udint_to_string;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_LWORD"))
+		return function_udint_to_lword;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_UINT"))
+		return function_udint_to_uint;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_LREAL"))
+		return function_udint_to_lreal;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_BYTE"))
+		return function_udint_to_byte;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_USINT"))
+		return function_udint_to_usint;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_ULINT"))
+		return function_udint_to_ulint;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_BOOL"))
+		return function_udint_to_bool;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_TIME"))
+		return function_udint_to_time;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_INT"))
+		return function_udint_to_int;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_REAL"))
+		return function_word_to_real;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_SINT"))
+		return function_word_to_sint;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_LINT"))
+		return function_word_to_lint;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_DINT"))
+		return function_word_to_dint;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_DATE"))
+		return function_word_to_date;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_DWORD"))
+		return function_word_to_dword;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_DT"))
+		return function_word_to_dt;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_TOD"))
+		return function_word_to_tod;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_UDINT"))
+		return function_word_to_udint;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_WORD"))
+		return function_word_to_word;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_WSTRING"))
+		return function_word_to_wstring;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_STRING"))
+		return function_word_to_string;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_LWORD"))
+		return function_word_to_lword;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_UINT"))
+		return function_word_to_uint;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_LREAL"))
+		return function_word_to_lreal;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_BYTE"))
+		return function_word_to_byte;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_USINT"))
+		return function_word_to_usint;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_ULINT"))
+		return function_word_to_ulint;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_BOOL"))
+		return function_word_to_bool;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_TIME"))
+		return function_word_to_time;
+
+	if (!strcasecmp(function_name->value, "WORD_TO_INT"))
+		return function_word_to_int;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_REAL"))
+		return function_wstring_to_real;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_SINT"))
+		return function_wstring_to_sint;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_LINT"))
+		return function_wstring_to_lint;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_DINT"))
+		return function_wstring_to_dint;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_DATE"))
+		return function_wstring_to_date;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_DWORD"))
+		return function_wstring_to_dword;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_DT"))
+		return function_wstring_to_dt;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_TOD"))
+		return function_wstring_to_tod;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_UDINT"))
+		return function_wstring_to_udint;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_WORD"))
+		return function_wstring_to_word;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_WSTRING"))
+		return function_wstring_to_wstring;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_STRING"))
+		return function_wstring_to_string;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_LWORD"))
+		return function_wstring_to_lword;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_UINT"))
+		return function_wstring_to_uint;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_LREAL"))
+		return function_wstring_to_lreal;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_BYTE"))
+		return function_wstring_to_byte;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_USINT"))
+		return function_wstring_to_usint;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_ULINT"))
+		return function_wstring_to_ulint;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_BOOL"))
+		return function_wstring_to_bool;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_TIME"))
+		return function_wstring_to_time;
+
+	if (!strcasecmp(function_name->value, "WSTRING_TO_INT"))
+		return function_wstring_to_int;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_REAL"))
+		return function_string_to_real;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_SINT"))
+		return function_string_to_sint;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_LINT"))
+		return function_string_to_lint;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_DINT"))
+		return function_string_to_dint;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_DATE"))
+		return function_string_to_date;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_DWORD"))
+		return function_string_to_dword;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_DT"))
+		return function_string_to_dt;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_TOD"))
+		return function_string_to_tod;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_UDINT"))
+		return function_string_to_udint;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_WORD"))
+		return function_string_to_word;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_WSTRING"))
+		return function_string_to_wstring;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_STRING"))
+		return function_string_to_string;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_LWORD"))
+		return function_string_to_lword;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_UINT"))
+		return function_string_to_uint;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_LREAL"))
+		return function_string_to_lreal;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_BYTE"))
+		return function_string_to_byte;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_USINT"))
+		return function_string_to_usint;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_ULINT"))
+		return function_string_to_ulint;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_BOOL"))
+		return function_string_to_bool;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_TIME"))
+		return function_string_to_time;
+
+	if (!strcasecmp(function_name->value, "STRING_TO_INT"))
+		return function_string_to_int;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_REAL"))
+		return function_lword_to_real;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_SINT"))
+		return function_lword_to_sint;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_LINT"))
+		return function_lword_to_lint;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_DINT"))
+		return function_lword_to_dint;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_DATE"))
+		return function_lword_to_date;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_DWORD"))
+		return function_lword_to_dword;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_DT"))
+		return function_lword_to_dt;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_TOD"))
+		return function_lword_to_tod;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_UDINT"))
+		return function_lword_to_udint;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_WORD"))
+		return function_lword_to_word;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_WSTRING"))
+		return function_lword_to_wstring;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_STRING"))
+		return function_lword_to_string;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_LWORD"))
+		return function_lword_to_lword;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_UINT"))
+		return function_lword_to_uint;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_LREAL"))
+		return function_lword_to_lreal;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_BYTE"))
+		return function_lword_to_byte;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_USINT"))
+		return function_lword_to_usint;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_ULINT"))
+		return function_lword_to_ulint;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_BOOL"))
+		return function_lword_to_bool;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_TIME"))
+		return function_lword_to_time;
+
+	if (!strcasecmp(function_name->value, "LWORD_TO_INT"))
+		return function_lword_to_int;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_REAL"))
+		return function_uint_to_real;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_SINT"))
+		return function_uint_to_sint;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_LINT"))
+		return function_uint_to_lint;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_DINT"))
+		return function_uint_to_dint;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_DATE"))
+		return function_uint_to_date;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_DWORD"))
+		return function_uint_to_dword;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_DT"))
+		return function_uint_to_dt;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_TOD"))
+		return function_uint_to_tod;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_UDINT"))
+		return function_uint_to_udint;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_WORD"))
+		return function_uint_to_word;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_WSTRING"))
+		return function_uint_to_wstring;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_STRING"))
+		return function_uint_to_string;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_LWORD"))
+		return function_uint_to_lword;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_UINT"))
+		return function_uint_to_uint;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_LREAL"))
+		return function_uint_to_lreal;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_BYTE"))
+		return function_uint_to_byte;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_USINT"))
+		return function_uint_to_usint;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_ULINT"))
+		return function_uint_to_ulint;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_BOOL"))
+		return function_uint_to_bool;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_TIME"))
+		return function_uint_to_time;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_INT"))
+		return function_uint_to_int;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_REAL"))
+		return function_lreal_to_real;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_SINT"))
+		return function_lreal_to_sint;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_LINT"))
+		return function_lreal_to_lint;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_DINT"))
+		return function_lreal_to_dint;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_DATE"))
+		return function_lreal_to_date;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_DWORD"))
+		return function_lreal_to_dword;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_DT"))
+		return function_lreal_to_dt;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_TOD"))
+		return function_lreal_to_tod;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_UDINT"))
+		return function_lreal_to_udint;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_WORD"))
+		return function_lreal_to_word;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_WSTRING"))
+		return function_lreal_to_wstring;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_STRING"))
+		return function_lreal_to_string;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_LWORD"))
+		return function_lreal_to_lword;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_UINT"))
+		return function_lreal_to_uint;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_LREAL"))
+		return function_lreal_to_lreal;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_BYTE"))
+		return function_lreal_to_byte;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_USINT"))
+		return function_lreal_to_usint;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_ULINT"))
+		return function_lreal_to_ulint;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_BOOL"))
+		return function_lreal_to_bool;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_TIME"))
+		return function_lreal_to_time;
+
+	if (!strcasecmp(function_name->value, "LREAL_TO_INT"))
+		return function_lreal_to_int;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_REAL"))
+		return function_byte_to_real;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_SINT"))
+		return function_byte_to_sint;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_LINT"))
+		return function_byte_to_lint;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_DINT"))
+		return function_byte_to_dint;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_DATE"))
+		return function_byte_to_date;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_DWORD"))
+		return function_byte_to_dword;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_DT"))
+		return function_byte_to_dt;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_TOD"))
+		return function_byte_to_tod;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_UDINT"))
+		return function_byte_to_udint;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_WORD"))
+		return function_byte_to_word;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_WSTRING"))
+		return function_byte_to_wstring;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_STRING"))
+		return function_byte_to_string;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_LWORD"))
+		return function_byte_to_lword;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_UINT"))
+		return function_byte_to_uint;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_LREAL"))
+		return function_byte_to_lreal;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_BYTE"))
+		return function_byte_to_byte;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_USINT"))
+		return function_byte_to_usint;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_ULINT"))
+		return function_byte_to_ulint;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_BOOL"))
+		return function_byte_to_bool;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_TIME"))
+		return function_byte_to_time;
+
+	if (!strcasecmp(function_name->value, "BYTE_TO_INT"))
+		return function_byte_to_int;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_REAL"))
+		return function_usint_to_real;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_SINT"))
+		return function_usint_to_sint;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_LINT"))
+		return function_usint_to_lint;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_DINT"))
+		return function_usint_to_dint;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_DATE"))
+		return function_usint_to_date;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_DWORD"))
+		return function_usint_to_dword;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_DT"))
+		return function_usint_to_dt;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_TOD"))
+		return function_usint_to_tod;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_UDINT"))
+		return function_usint_to_udint;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_WORD"))
+		return function_usint_to_word;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_WSTRING"))
+		return function_usint_to_wstring;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_STRING"))
+		return function_usint_to_string;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_LWORD"))
+		return function_usint_to_lword;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_UINT"))
+		return function_usint_to_uint;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_LREAL"))
+		return function_usint_to_lreal;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_BYTE"))
+		return function_usint_to_byte;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_USINT"))
+		return function_usint_to_usint;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_ULINT"))
+		return function_usint_to_ulint;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_BOOL"))
+		return function_usint_to_bool;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_TIME"))
+		return function_usint_to_time;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_INT"))
+		return function_usint_to_int;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_REAL"))
+		return function_ulint_to_real;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_SINT"))
+		return function_ulint_to_sint;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_LINT"))
+		return function_ulint_to_lint;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_DINT"))
+		return function_ulint_to_dint;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_DATE"))
+		return function_ulint_to_date;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_DWORD"))
+		return function_ulint_to_dword;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_DT"))
+		return function_ulint_to_dt;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_TOD"))
+		return function_ulint_to_tod;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_UDINT"))
+		return function_ulint_to_udint;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_WORD"))
+		return function_ulint_to_word;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_WSTRING"))
+		return function_ulint_to_wstring;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_STRING"))
+		return function_ulint_to_string;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_LWORD"))
+		return function_ulint_to_lword;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_UINT"))
+		return function_ulint_to_uint;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_LREAL"))
+		return function_ulint_to_lreal;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_BYTE"))
+		return function_ulint_to_byte;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_USINT"))
+		return function_ulint_to_usint;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_ULINT"))
+		return function_ulint_to_ulint;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_BOOL"))
+		return function_ulint_to_bool;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_TIME"))
+		return function_ulint_to_time;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_INT"))
+		return function_ulint_to_int;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_REAL"))
+		return function_bool_to_real;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_SINT"))
+		return function_bool_to_sint;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_LINT"))
+		return function_bool_to_lint;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_DINT"))
+		return function_bool_to_dint;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_DATE"))
+		return function_bool_to_date;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_DWORD"))
+		return function_bool_to_dword;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_DT"))
+		return function_bool_to_dt;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_TOD"))
+		return function_bool_to_tod;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_UDINT"))
+		return function_bool_to_udint;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_WORD"))
+		return function_bool_to_word;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_WSTRING"))
+		return function_bool_to_wstring;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_STRING"))
+		return function_bool_to_string;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_LWORD"))
+		return function_bool_to_lword;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_UINT"))
+		return function_bool_to_uint;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_LREAL"))
+		return function_bool_to_lreal;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_BYTE"))
+		return function_bool_to_byte;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_USINT"))
+		return function_bool_to_usint;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_ULINT"))
+		return function_bool_to_ulint;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_BOOL"))
+		return function_bool_to_bool;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_TIME"))
+		return function_bool_to_time;
+
+	if (!strcasecmp(function_name->value, "BOOL_TO_INT"))
+		return function_bool_to_int;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_REAL"))
+		return function_time_to_real;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_SINT"))
+		return function_time_to_sint;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_LINT"))
+		return function_time_to_lint;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_DINT"))
+		return function_time_to_dint;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_DATE"))
+		return function_time_to_date;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_DWORD"))
+		return function_time_to_dword;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_DT"))
+		return function_time_to_dt;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_TOD"))
+		return function_time_to_tod;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_UDINT"))
+		return function_time_to_udint;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_WORD"))
+		return function_time_to_word;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_WSTRING"))
+		return function_time_to_wstring;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_STRING"))
+		return function_time_to_string;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_LWORD"))
+		return function_time_to_lword;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_UINT"))
+		return function_time_to_uint;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_LREAL"))
+		return function_time_to_lreal;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_BYTE"))
+		return function_time_to_byte;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_USINT"))
+		return function_time_to_usint;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_ULINT"))
+		return function_time_to_ulint;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_BOOL"))
+		return function_time_to_bool;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_TIME"))
+		return function_time_to_time;
+
+	if (!strcasecmp(function_name->value, "TIME_TO_INT"))
+		return function_time_to_int;
+
+	if (!strcasecmp(function_name->value, "INT_TO_REAL"))
+		return function_int_to_real;
+
+	if (!strcasecmp(function_name->value, "INT_TO_SINT"))
+		return function_int_to_sint;
+
+	if (!strcasecmp(function_name->value, "INT_TO_LINT"))
+		return function_int_to_lint;
+
+	if (!strcasecmp(function_name->value, "INT_TO_DINT"))
+		return function_int_to_dint;
+
+	if (!strcasecmp(function_name->value, "INT_TO_DATE"))
+		return function_int_to_date;
+
+	if (!strcasecmp(function_name->value, "INT_TO_DWORD"))
+		return function_int_to_dword;
+
+	if (!strcasecmp(function_name->value, "INT_TO_DT"))
+		return function_int_to_dt;
+
+	if (!strcasecmp(function_name->value, "INT_TO_TOD"))
+		return function_int_to_tod;
+
+	if (!strcasecmp(function_name->value, "INT_TO_UDINT"))
+		return function_int_to_udint;
+
+	if (!strcasecmp(function_name->value, "INT_TO_WORD"))
+		return function_int_to_word;
+
+	if (!strcasecmp(function_name->value, "INT_TO_WSTRING"))
+		return function_int_to_wstring;
+
+	if (!strcasecmp(function_name->value, "INT_TO_STRING"))
+		return function_int_to_string;
+
+	if (!strcasecmp(function_name->value, "INT_TO_LWORD"))
+		return function_int_to_lword;
+
+	if (!strcasecmp(function_name->value, "INT_TO_UINT"))
+		return function_int_to_uint;
+
+	if (!strcasecmp(function_name->value, "INT_TO_LREAL"))
+		return function_int_to_lreal;
+
+	if (!strcasecmp(function_name->value, "INT_TO_BYTE"))
+		return function_int_to_byte;
+
+	if (!strcasecmp(function_name->value, "INT_TO_USINT"))
+		return function_int_to_usint;
+
+	if (!strcasecmp(function_name->value, "INT_TO_ULINT"))
+		return function_int_to_ulint;
+
+	if (!strcasecmp(function_name->value, "INT_TO_BOOL"))
+		return function_int_to_bool;
+
+	if (!strcasecmp(function_name->value, "INT_TO_TIME"))
+		return function_int_to_time;
+
+	if (!strcasecmp(function_name->value, "INT_TO_INT"))
+		return function_int_to_int;
+
+	if (!strcasecmp(function_name->value, "TRUNC"))
+		return function_trunc;
+
+	if (!strcasecmp(function_name->value, "BCD_TO_SINT"))
+		return function_bcd_to_sint;
+
+	if (!strcasecmp(function_name->value, "BCD_TO_LINT"))
+		return function_bcd_to_lint;
+
+	if (!strcasecmp(function_name->value, "BCD_TO_DINT"))
+		return function_bcd_to_dint;
+
+	if (!strcasecmp(function_name->value, "BCD_TO_UDINT"))
+		return function_bcd_to_udint;
+
+	if (!strcasecmp(function_name->value, "BCD_TO_UINT"))
+		return function_bcd_to_uint;
+
+	if (!strcasecmp(function_name->value, "BCD_TO_USINT"))
+		return function_bcd_to_usint;
+
+	if (!strcasecmp(function_name->value, "BCD_TO_ULINT"))
+		return function_bcd_to_ulint;
+
+	if (!strcasecmp(function_name->value, "BCD_TO_INT"))
+		return function_bcd_to_int;
+
+	if (!strcasecmp(function_name->value, "SINT_TO_BCD"))
+		return function_sint_to_bcd;
+
+	if (!strcasecmp(function_name->value, "LINT_TO_BCD"))
+		return function_lint_to_bcd;
+
+	if (!strcasecmp(function_name->value, "DINT_TO_BCD"))
+		return function_dint_to_bcd;
+
+	if (!strcasecmp(function_name->value, "UDINT_TO_BCD"))
+		return function_udint_to_bcd;
+
+	if (!strcasecmp(function_name->value, "UINT_TO_BCD"))
+		return function_uint_to_bcd;
+
+	if (!strcasecmp(function_name->value, "USINT_TO_BCD"))
+		return function_usint_to_bcd;
+
+	if (!strcasecmp(function_name->value, "ULINT_TO_BCD"))
+		return function_ulint_to_bcd;
+
+	if (!strcasecmp(function_name->value, "INT_TO_BCD"))
+		return function_int_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;
+}
+

--- a/stage4/generate_cc/search_constant_type.cc	Thu Jun 14 08:58:10 2007 +0200
+++ b/stage4/generate_cc/search_constant_type.cc	Mon Jun 18 14:45:03 2007 +0200
@@ -43,13 +43,26 @@
 /* B 1.3.1 - Elementary Data Types */
 /***********************************/
   static real_type_name_c     real_type_name;
-  static int_type_name_c      int_type_name;
-  static string_type_name_c   string_type_name;
-  static wstring_type_name_c  wstring_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 date_type_name_c     date_type_name;
-  static dt_type_name_c       dt_type_name;
-  static tod_type_name_c      tod_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;
@@ -115,14 +128,28 @@
     void *visit(date_and_time_c *symbol) {return (void *)&dt_type_name;}
 };
 
+
 real_type_name_c     search_constant_type_c::real_type_name;
-int_type_name_c      search_constant_type_c::int_type_name;
-string_type_name_c   search_constant_type_c::string_type_name;
-wstring_type_name_c  search_constant_type_c::wstring_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;
-date_type_name_c     search_constant_type_c::date_type_name;
-dt_type_name_c       search_constant_type_c::dt_type_name;
-tod_type_name_c      search_constant_type_c::tod_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;

--- a/stage4/generate_cc/search_expression_type.cc	Thu Jun 14 08:58:10 2007 +0200
+++ b/stage4/generate_cc/search_expression_type.cc	Mon Jun 18 14:45:03 2007 +0200
@@ -32,6 +32,10 @@
  *       etc...
  */
 
+#include "function_type_decl.h"
+#include "get_function_type_decl.c"
+
+#if 0
 typedef enum {function_add,
               function_sub,
               function_and,
@@ -53,6 +57,7 @@
     return function_sqrt;
   else return function_none;
 }
+#endif
 
 
 symbol_c *generate_param_name(const char *name) {
@@ -157,12 +162,17 @@
   private:
 
   void *compute_standard_function_st(function_invocation_c *symbol) {
+#if 0
     symbol_c *current_type = NULL;
     symbol_c *return_type = NULL;
+#endif
+
     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;
+    #include "search_type_code.c"
+    
+#if 0
     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) {
@@ -248,14 +258,15 @@
         default: ERROR;
       }
     }
-    
     return (void *)return_type;
+#endif
+    
   }
 
   public:
 
   void *compute_standard_function_il(il_function_call_c *symbol, symbol_c *param_type) {
-    symbol_c *current_type = NULL;
+    /*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;
@@ -300,7 +311,7 @@
     return (void *)return_type;
   }
 
-  static bool_type_name_c bool_type_name;
+  /*static bool_type_name_c bool_type_name;*/
 
   /* A helper function... */
   void *compute_boolean_expression(symbol_c *left_type, symbol_c *right_type) {
@@ -502,5 +513,5 @@
 
 };
 
-bool_type_name_c     search_expression_type_c::bool_type_name;
-
+/*bool_type_name_c     search_expression_type_c::bool_type_name;*/
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/stage4/generate_cc/search_type_code.c	Mon Jun 18 14:45:03 2007 +0200
@@ -0,0 +1,17249 @@
+
+/****
+ * IEC 61131-3 standard function lib
+ * generated code, do not edit by hand
+ */
+switch(current_function_type){
+
+/****
+ *REAL_TO_REAL
+ */
+	case function_real_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_real*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_sint*/
+	break;
+
+/****
+ *REAL_TO_LINT
+ */
+	case function_real_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_lint*/
+	break;
+
+/****
+ *REAL_TO_DINT
+ */
+	case function_real_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_dint*/
+	break;
+
+/****
+ *REAL_TO_DATE
+ */
+	case function_real_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_date*/
+	break;
+
+/****
+ *REAL_TO_DWORD
+ */
+	case function_real_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_dword*/
+	break;
+
+/****
+ *REAL_TO_DT
+ */
+	case function_real_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_dt*/
+	break;
+
+/****
+ *REAL_TO_TOD
+ */
+	case function_real_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_tod*/
+	break;
+
+/****
+ *REAL_TO_UDINT
+ */
+	case function_real_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_udint*/
+	break;
+
+/****
+ *REAL_TO_WORD
+ */
+	case function_real_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_word*/
+	break;
+
+/****
+ *REAL_TO_WSTRING
+ */
+	case function_real_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_wstring*/
+	break;
+
+/****
+ *REAL_TO_STRING
+ */
+	case function_real_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_string*/
+	break;
+
+/****
+ *REAL_TO_LWORD
+ */
+	case function_real_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_lword*/
+	break;
+
+/****
+ *REAL_TO_UINT
+ */
+	case function_real_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_uint*/
+	break;
+
+/****
+ *REAL_TO_LREAL
+ */
+	case function_real_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_lreal*/
+	break;
+
+/****
+ *REAL_TO_BYTE
+ */
+	case function_real_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_byte*/
+	break;
+
+/****
+ *REAL_TO_USINT
+ */
+	case function_real_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_usint*/
+	break;
+
+/****
+ *REAL_TO_ULINT
+ */
+	case function_real_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_ulint*/
+	break;
+
+/****
+ *REAL_TO_BOOL
+ */
+	case function_real_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_bool*/
+	break;
+
+/****
+ *REAL_TO_TIME
+ */
+	case function_real_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_time*/
+	break;
+
+/****
+ *REAL_TO_INT
+ */
+	case function_real_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(real_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_real_to_int*/
+	break;
+
+/****
+ *SINT_TO_REAL
+ */
+	case function_sint_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_real*/
+	break;
+
+/****
+ *SINT_TO_SINT
+ */
+	case function_sint_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_sint*/
+	break;
+
+/****
+ *SINT_TO_LINT
+ */
+	case function_sint_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_lint*/
+	break;
+
+/****
+ *SINT_TO_DINT
+ */
+	case function_sint_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_dint*/
+	break;
+
+/****
+ *SINT_TO_DATE
+ */
+	case function_sint_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_date*/
+	break;
+
+/****
+ *SINT_TO_DWORD
+ */
+	case function_sint_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_dword*/
+	break;
+
+/****
+ *SINT_TO_DT
+ */
+	case function_sint_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_dt*/
+	break;
+
+/****
+ *SINT_TO_TOD
+ */
+	case function_sint_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_tod*/
+	break;
+
+/****
+ *SINT_TO_UDINT
+ */
+	case function_sint_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_udint*/
+	break;
+
+/****
+ *SINT_TO_WORD
+ */
+	case function_sint_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_word*/
+	break;
+
+/****
+ *SINT_TO_WSTRING
+ */
+	case function_sint_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_wstring*/
+	break;
+
+/****
+ *SINT_TO_STRING
+ */
+	case function_sint_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_string*/
+	break;
+
+/****
+ *SINT_TO_LWORD
+ */
+	case function_sint_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_lword*/
+	break;
+
+/****
+ *SINT_TO_UINT
+ */
+	case function_sint_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_uint*/
+	break;
+
+/****
+ *SINT_TO_LREAL
+ */
+	case function_sint_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_lreal*/
+	break;
+
+/****
+ *SINT_TO_BYTE
+ */
+	case function_sint_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_byte*/
+	break;
+
+/****
+ *SINT_TO_USINT
+ */
+	case function_sint_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_usint*/
+	break;
+
+/****
+ *SINT_TO_ULINT
+ */
+	case function_sint_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_ulint*/
+	break;
+
+/****
+ *SINT_TO_BOOL
+ */
+	case function_sint_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_bool*/
+	break;
+
+/****
+ *SINT_TO_TIME
+ */
+	case function_sint_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_time*/
+	break;
+
+/****
+ *SINT_TO_INT
+ */
+	case function_sint_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_int*/
+	break;
+
+/****
+ *LINT_TO_REAL
+ */
+	case function_lint_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_real*/
+	break;
+
+/****
+ *LINT_TO_SINT
+ */
+	case function_lint_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_sint*/
+	break;
+
+/****
+ *LINT_TO_LINT
+ */
+	case function_lint_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_lint*/
+	break;
+
+/****
+ *LINT_TO_DINT
+ */
+	case function_lint_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_dint*/
+	break;
+
+/****
+ *LINT_TO_DATE
+ */
+	case function_lint_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_date*/
+	break;
+
+/****
+ *LINT_TO_DWORD
+ */
+	case function_lint_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_dword*/
+	break;
+
+/****
+ *LINT_TO_DT
+ */
+	case function_lint_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_dt*/
+	break;
+
+/****
+ *LINT_TO_TOD
+ */
+	case function_lint_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_tod*/
+	break;
+
+/****
+ *LINT_TO_UDINT
+ */
+	case function_lint_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_udint*/
+	break;
+
+/****
+ *LINT_TO_WORD
+ */
+	case function_lint_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_word*/
+	break;
+
+/****
+ *LINT_TO_WSTRING
+ */
+	case function_lint_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_wstring*/
+	break;
+
+/****
+ *LINT_TO_STRING
+ */
+	case function_lint_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_string*/
+	break;
+
+/****
+ *LINT_TO_LWORD
+ */
+	case function_lint_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_lword*/
+	break;
+
+/****
+ *LINT_TO_UINT
+ */
+	case function_lint_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_uint*/
+	break;
+
+/****
+ *LINT_TO_LREAL
+ */
+	case function_lint_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_lreal*/
+	break;
+
+/****
+ *LINT_TO_BYTE
+ */
+	case function_lint_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_byte*/
+	break;
+
+/****
+ *LINT_TO_USINT
+ */
+	case function_lint_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_usint*/
+	break;
+
+/****
+ *LINT_TO_ULINT
+ */
+	case function_lint_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_ulint*/
+	break;
+
+/****
+ *LINT_TO_BOOL
+ */
+	case function_lint_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_bool*/
+	break;
+
+/****
+ *LINT_TO_TIME
+ */
+	case function_lint_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_time*/
+	break;
+
+/****
+ *LINT_TO_INT
+ */
+	case function_lint_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_int*/
+	break;
+
+/****
+ *DINT_TO_REAL
+ */
+	case function_dint_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_real*/
+	break;
+
+/****
+ *DINT_TO_SINT
+ */
+	case function_dint_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_sint*/
+	break;
+
+/****
+ *DINT_TO_LINT
+ */
+	case function_dint_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_lint*/
+	break;
+
+/****
+ *DINT_TO_DINT
+ */
+	case function_dint_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_dint*/
+	break;
+
+/****
+ *DINT_TO_DATE
+ */
+	case function_dint_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_date*/
+	break;
+
+/****
+ *DINT_TO_DWORD
+ */
+	case function_dint_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_dword*/
+	break;
+
+/****
+ *DINT_TO_DT
+ */
+	case function_dint_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_dt*/
+	break;
+
+/****
+ *DINT_TO_TOD
+ */
+	case function_dint_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_tod*/
+	break;
+
+/****
+ *DINT_TO_UDINT
+ */
+	case function_dint_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_udint*/
+	break;
+
+/****
+ *DINT_TO_WORD
+ */
+	case function_dint_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_word*/
+	break;
+
+/****
+ *DINT_TO_WSTRING
+ */
+	case function_dint_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_wstring*/
+	break;
+
+/****
+ *DINT_TO_STRING
+ */
+	case function_dint_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_string*/
+	break;
+
+/****
+ *DINT_TO_LWORD
+ */
+	case function_dint_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_lword*/
+	break;
+
+/****
+ *DINT_TO_UINT
+ */
+	case function_dint_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_uint*/
+	break;
+
+/****
+ *DINT_TO_LREAL
+ */
+	case function_dint_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_lreal*/
+	break;
+
+/****
+ *DINT_TO_BYTE
+ */
+	case function_dint_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_byte*/
+	break;
+
+/****
+ *DINT_TO_USINT
+ */
+	case function_dint_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_usint*/
+	break;
+
+/****
+ *DINT_TO_ULINT
+ */
+	case function_dint_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_ulint*/
+	break;
+
+/****
+ *DINT_TO_BOOL
+ */
+	case function_dint_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_bool*/
+	break;
+
+/****
+ *DINT_TO_TIME
+ */
+	case function_dint_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_time*/
+	break;
+
+/****
+ *DINT_TO_INT
+ */
+	case function_dint_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_to_int*/
+	break;
+
+/****
+ *DATE_TO_REAL
+ */
+	case function_date_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_real*/
+	break;
+
+/****
+ *DATE_TO_SINT
+ */
+	case function_date_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_sint*/
+	break;
+
+/****
+ *DATE_TO_LINT
+ */
+	case function_date_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_lint*/
+	break;
+
+/****
+ *DATE_TO_DINT
+ */
+	case function_date_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_dint*/
+	break;
+
+/****
+ *DATE_TO_DATE
+ */
+	case function_date_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_date*/
+	break;
+
+/****
+ *DATE_TO_DWORD
+ */
+	case function_date_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_dword*/
+	break;
+
+/****
+ *DATE_TO_DT
+ */
+	case function_date_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_dt*/
+	break;
+
+/****
+ *DATE_TO_TOD
+ */
+	case function_date_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_tod*/
+	break;
+
+/****
+ *DATE_TO_UDINT
+ */
+	case function_date_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_udint*/
+	break;
+
+/****
+ *DATE_TO_WORD
+ */
+	case function_date_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_word*/
+	break;
+
+/****
+ *DATE_TO_WSTRING
+ */
+	case function_date_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_wstring*/
+	break;
+
+/****
+ *DATE_TO_STRING
+ */
+	case function_date_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_string*/
+	break;
+
+/****
+ *DATE_TO_LWORD
+ */
+	case function_date_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_lword*/
+	break;
+
+/****
+ *DATE_TO_UINT
+ */
+	case function_date_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_uint*/
+	break;
+
+/****
+ *DATE_TO_LREAL
+ */
+	case function_date_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_lreal*/
+	break;
+
+/****
+ *DATE_TO_BYTE
+ */
+	case function_date_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_byte*/
+	break;
+
+/****
+ *DATE_TO_USINT
+ */
+	case function_date_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_usint*/
+	break;
+
+/****
+ *DATE_TO_ULINT
+ */
+	case function_date_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_ulint*/
+	break;
+
+/****
+ *DATE_TO_BOOL
+ */
+	case function_date_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_bool*/
+	break;
+
+/****
+ *DATE_TO_TIME
+ */
+	case function_date_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_time*/
+	break;
+
+/****
+ *DATE_TO_INT
+ */
+	case function_date_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_date_to_int*/
+	break;
+
+/****
+ *DWORD_TO_REAL
+ */
+	case function_dword_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_real*/
+	break;
+
+/****
+ *DWORD_TO_SINT
+ */
+	case function_dword_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_sint*/
+	break;
+
+/****
+ *DWORD_TO_LINT
+ */
+	case function_dword_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_lint*/
+	break;
+
+/****
+ *DWORD_TO_DINT
+ */
+	case function_dword_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_dint*/
+	break;
+
+/****
+ *DWORD_TO_DATE
+ */
+	case function_dword_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_date*/
+	break;
+
+/****
+ *DWORD_TO_DWORD
+ */
+	case function_dword_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_dword*/
+	break;
+
+/****
+ *DWORD_TO_DT
+ */
+	case function_dword_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_dt*/
+	break;
+
+/****
+ *DWORD_TO_TOD
+ */
+	case function_dword_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_tod*/
+	break;
+
+/****
+ *DWORD_TO_UDINT
+ */
+	case function_dword_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_udint*/
+	break;
+
+/****
+ *DWORD_TO_WORD
+ */
+	case function_dword_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_word*/
+	break;
+
+/****
+ *DWORD_TO_WSTRING
+ */
+	case function_dword_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_wstring*/
+	break;
+
+/****
+ *DWORD_TO_STRING
+ */
+	case function_dword_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_string*/
+	break;
+
+/****
+ *DWORD_TO_LWORD
+ */
+	case function_dword_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_lword*/
+	break;
+
+/****
+ *DWORD_TO_UINT
+ */
+	case function_dword_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_uint*/
+	break;
+
+/****
+ *DWORD_TO_LREAL
+ */
+	case function_dword_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_lreal*/
+	break;
+
+/****
+ *DWORD_TO_BYTE
+ */
+	case function_dword_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_byte*/
+	break;
+
+/****
+ *DWORD_TO_USINT
+ */
+	case function_dword_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_usint*/
+	break;
+
+/****
+ *DWORD_TO_ULINT
+ */
+	case function_dword_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_ulint*/
+	break;
+
+/****
+ *DWORD_TO_BOOL
+ */
+	case function_dword_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_bool*/
+	break;
+
+/****
+ *DWORD_TO_TIME
+ */
+	case function_dword_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_time*/
+	break;
+
+/****
+ *DWORD_TO_INT
+ */
+	case function_dword_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dword_to_int*/
+	break;
+
+/****
+ *DT_TO_REAL
+ */
+	case function_dt_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_real*/
+	break;
+
+/****
+ *DT_TO_SINT
+ */
+	case function_dt_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_sint*/
+	break;
+
+/****
+ *DT_TO_LINT
+ */
+	case function_dt_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_lint*/
+	break;
+
+/****
+ *DT_TO_DINT
+ */
+	case function_dt_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_dint*/
+	break;
+
+/****
+ *DT_TO_DATE
+ */
+	case function_dt_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_date*/
+	break;
+
+/****
+ *DT_TO_DWORD
+ */
+	case function_dt_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_dword*/
+	break;
+
+/****
+ *DT_TO_DT
+ */
+	case function_dt_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_dt*/
+	break;
+
+/****
+ *DT_TO_TOD
+ */
+	case function_dt_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_tod*/
+	break;
+
+/****
+ *DT_TO_UDINT
+ */
+	case function_dt_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_udint*/
+	break;
+
+/****
+ *DT_TO_WORD
+ */
+	case function_dt_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_word*/
+	break;
+
+/****
+ *DT_TO_WSTRING
+ */
+	case function_dt_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_wstring*/
+	break;
+
+/****
+ *DT_TO_STRING
+ */
+	case function_dt_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_string*/
+	break;
+
+/****
+ *DT_TO_LWORD
+ */
+	case function_dt_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_lword*/
+	break;
+
+/****
+ *DT_TO_UINT
+ */
+	case function_dt_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_uint*/
+	break;
+
+/****
+ *DT_TO_LREAL
+ */
+	case function_dt_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_lreal*/
+	break;
+
+/****
+ *DT_TO_BYTE
+ */
+	case function_dt_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_byte*/
+	break;
+
+/****
+ *DT_TO_USINT
+ */
+	case function_dt_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_usint*/
+	break;
+
+/****
+ *DT_TO_ULINT
+ */
+	case function_dt_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_ulint*/
+	break;
+
+/****
+ *DT_TO_BOOL
+ */
+	case function_dt_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_bool*/
+	break;
+
+/****
+ *DT_TO_TIME
+ */
+	case function_dt_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_time*/
+	break;
+
+/****
+ *DT_TO_INT
+ */
+	case function_dt_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dt_to_int*/
+	break;
+
+/****
+ *TOD_TO_REAL
+ */
+	case function_tod_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_real*/
+	break;
+
+/****
+ *TOD_TO_SINT
+ */
+	case function_tod_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_sint*/
+	break;
+
+/****
+ *TOD_TO_LINT
+ */
+	case function_tod_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_lint*/
+	break;
+
+/****
+ *TOD_TO_DINT
+ */
+	case function_tod_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_dint*/
+	break;
+
+/****
+ *TOD_TO_DATE
+ */
+	case function_tod_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_date*/
+	break;
+
+/****
+ *TOD_TO_DWORD
+ */
+	case function_tod_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_dword*/
+	break;
+
+/****
+ *TOD_TO_DT
+ */
+	case function_tod_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_dt*/
+	break;
+
+/****
+ *TOD_TO_TOD
+ */
+	case function_tod_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_tod*/
+	break;
+
+/****
+ *TOD_TO_UDINT
+ */
+	case function_tod_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_udint*/
+	break;
+
+/****
+ *TOD_TO_WORD
+ */
+	case function_tod_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_word*/
+	break;
+
+/****
+ *TOD_TO_WSTRING
+ */
+	case function_tod_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_wstring*/
+	break;
+
+/****
+ *TOD_TO_STRING
+ */
+	case function_tod_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_string*/
+	break;
+
+/****
+ *TOD_TO_LWORD
+ */
+	case function_tod_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_lword*/
+	break;
+
+/****
+ *TOD_TO_UINT
+ */
+	case function_tod_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_uint*/
+	break;
+
+/****
+ *TOD_TO_LREAL
+ */
+	case function_tod_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_lreal*/
+	break;
+
+/****
+ *TOD_TO_BYTE
+ */
+	case function_tod_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_byte*/
+	break;
+
+/****
+ *TOD_TO_USINT
+ */
+	case function_tod_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_usint*/
+	break;
+
+/****
+ *TOD_TO_ULINT
+ */
+	case function_tod_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_ulint*/
+	break;
+
+/****
+ *TOD_TO_BOOL
+ */
+	case function_tod_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_bool*/
+	break;
+
+/****
+ *TOD_TO_TIME
+ */
+	case function_tod_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_time*/
+	break;
+
+/****
+ *TOD_TO_INT
+ */
+	case function_tod_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_tod_to_int*/
+	break;
+
+/****
+ *UDINT_TO_REAL
+ */
+	case function_udint_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_real*/
+	break;
+
+/****
+ *UDINT_TO_SINT
+ */
+	case function_udint_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_sint*/
+	break;
+
+/****
+ *UDINT_TO_LINT
+ */
+	case function_udint_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_lint*/
+	break;
+
+/****
+ *UDINT_TO_DINT
+ */
+	case function_udint_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_dint*/
+	break;
+
+/****
+ *UDINT_TO_DATE
+ */
+	case function_udint_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_date*/
+	break;
+
+/****
+ *UDINT_TO_DWORD
+ */
+	case function_udint_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_dword*/
+	break;
+
+/****
+ *UDINT_TO_DT
+ */
+	case function_udint_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_dt*/
+	break;
+
+/****
+ *UDINT_TO_TOD
+ */
+	case function_udint_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_tod*/
+	break;
+
+/****
+ *UDINT_TO_UDINT
+ */
+	case function_udint_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_udint*/
+	break;
+
+/****
+ *UDINT_TO_WORD
+ */
+	case function_udint_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_word*/
+	break;
+
+/****
+ *UDINT_TO_WSTRING
+ */
+	case function_udint_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_wstring*/
+	break;
+
+/****
+ *UDINT_TO_STRING
+ */
+	case function_udint_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_string*/
+	break;
+
+/****
+ *UDINT_TO_LWORD
+ */
+	case function_udint_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_lword*/
+	break;
+
+/****
+ *UDINT_TO_UINT
+ */
+	case function_udint_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_uint*/
+	break;
+
+/****
+ *UDINT_TO_LREAL
+ */
+	case function_udint_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_lreal*/
+	break;
+
+/****
+ *UDINT_TO_BYTE
+ */
+	case function_udint_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_byte*/
+	break;
+
+/****
+ *UDINT_TO_USINT
+ */
+	case function_udint_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_usint*/
+	break;
+
+/****
+ *UDINT_TO_ULINT
+ */
+	case function_udint_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_ulint*/
+	break;
+
+/****
+ *UDINT_TO_BOOL
+ */
+	case function_udint_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_bool*/
+	break;
+
+/****
+ *UDINT_TO_TIME
+ */
+	case function_udint_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_time*/
+	break;
+
+/****
+ *UDINT_TO_INT
+ */
+	case function_udint_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_to_int*/
+	break;
+
+/****
+ *WORD_TO_REAL
+ */
+	case function_word_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_real*/
+	break;
+
+/****
+ *WORD_TO_SINT
+ */
+	case function_word_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_sint*/
+	break;
+
+/****
+ *WORD_TO_LINT
+ */
+	case function_word_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_lint*/
+	break;
+
+/****
+ *WORD_TO_DINT
+ */
+	case function_word_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_dint*/
+	break;
+
+/****
+ *WORD_TO_DATE
+ */
+	case function_word_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_date*/
+	break;
+
+/****
+ *WORD_TO_DWORD
+ */
+	case function_word_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_dword*/
+	break;
+
+/****
+ *WORD_TO_DT
+ */
+	case function_word_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_dt*/
+	break;
+
+/****
+ *WORD_TO_TOD
+ */
+	case function_word_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_tod*/
+	break;
+
+/****
+ *WORD_TO_UDINT
+ */
+	case function_word_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_udint*/
+	break;
+
+/****
+ *WORD_TO_WORD
+ */
+	case function_word_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_word*/
+	break;
+
+/****
+ *WORD_TO_WSTRING
+ */
+	case function_word_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_wstring*/
+	break;
+
+/****
+ *WORD_TO_STRING
+ */
+	case function_word_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_string*/
+	break;
+
+/****
+ *WORD_TO_LWORD
+ */
+	case function_word_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_lword*/
+	break;
+
+/****
+ *WORD_TO_UINT
+ */
+	case function_word_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_uint*/
+	break;
+
+/****
+ *WORD_TO_LREAL
+ */
+	case function_word_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_lreal*/
+	break;
+
+/****
+ *WORD_TO_BYTE
+ */
+	case function_word_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_byte*/
+	break;
+
+/****
+ *WORD_TO_USINT
+ */
+	case function_word_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_usint*/
+	break;
+
+/****
+ *WORD_TO_ULINT
+ */
+	case function_word_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_ulint*/
+	break;
+
+/****
+ *WORD_TO_BOOL
+ */
+	case function_word_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_bool*/
+	break;
+
+/****
+ *WORD_TO_TIME
+ */
+	case function_word_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_time*/
+	break;
+
+/****
+ *WORD_TO_INT
+ */
+	case function_word_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(word_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_word_to_int*/
+	break;
+
+/****
+ *WSTRING_TO_REAL
+ */
+	case function_wstring_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_real*/
+	break;
+
+/****
+ *WSTRING_TO_SINT
+ */
+	case function_wstring_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_sint*/
+	break;
+
+/****
+ *WSTRING_TO_LINT
+ */
+	case function_wstring_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_lint*/
+	break;
+
+/****
+ *WSTRING_TO_DINT
+ */
+	case function_wstring_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_dint*/
+	break;
+
+/****
+ *WSTRING_TO_DATE
+ */
+	case function_wstring_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_date*/
+	break;
+
+/****
+ *WSTRING_TO_DWORD
+ */
+	case function_wstring_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_dword*/
+	break;
+
+/****
+ *WSTRING_TO_DT
+ */
+	case function_wstring_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_dt*/
+	break;
+
+/****
+ *WSTRING_TO_TOD
+ */
+	case function_wstring_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_tod*/
+	break;
+
+/****
+ *WSTRING_TO_UDINT
+ */
+	case function_wstring_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_udint*/
+	break;
+
+/****
+ *WSTRING_TO_WORD
+ */
+	case function_wstring_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_word*/
+	break;
+
+/****
+ *WSTRING_TO_WSTRING
+ */
+	case function_wstring_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_wstring*/
+	break;
+
+/****
+ *WSTRING_TO_STRING
+ */
+	case function_wstring_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_string*/
+	break;
+
+/****
+ *WSTRING_TO_LWORD
+ */
+	case function_wstring_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_lword*/
+	break;
+
+/****
+ *WSTRING_TO_UINT
+ */
+	case function_wstring_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_uint*/
+	break;
+
+/****
+ *WSTRING_TO_LREAL
+ */
+	case function_wstring_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_lreal*/
+	break;
+
+/****
+ *WSTRING_TO_BYTE
+ */
+	case function_wstring_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_byte*/
+	break;
+
+/****
+ *WSTRING_TO_USINT
+ */
+	case function_wstring_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_usint*/
+	break;
+
+/****
+ *WSTRING_TO_ULINT
+ */
+	case function_wstring_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_ulint*/
+	break;
+
+/****
+ *WSTRING_TO_BOOL
+ */
+	case function_wstring_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_bool*/
+	break;
+
+/****
+ *WSTRING_TO_TIME
+ */
+	case function_wstring_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_time*/
+	break;
+
+/****
+ *WSTRING_TO_INT
+ */
+	case function_wstring_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(wstring_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_wstring_to_int*/
+	break;
+
+/****
+ *STRING_TO_REAL
+ */
+	case function_string_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_real*/
+	break;
+
+/****
+ *STRING_TO_SINT
+ */
+	case function_string_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_sint*/
+	break;
+
+/****
+ *STRING_TO_LINT
+ */
+	case function_string_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_lint*/
+	break;
+
+/****
+ *STRING_TO_DINT
+ */
+	case function_string_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_dint*/
+	break;
+
+/****
+ *STRING_TO_DATE
+ */
+	case function_string_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_date*/
+	break;
+
+/****
+ *STRING_TO_DWORD
+ */
+	case function_string_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_dword*/
+	break;
+
+/****
+ *STRING_TO_DT
+ */
+	case function_string_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_dt*/
+	break;
+
+/****
+ *STRING_TO_TOD
+ */
+	case function_string_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_tod*/
+	break;
+
+/****
+ *STRING_TO_UDINT
+ */
+	case function_string_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_udint*/
+	break;
+
+/****
+ *STRING_TO_WORD
+ */
+	case function_string_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_word*/
+	break;
+
+/****
+ *STRING_TO_WSTRING
+ */
+	case function_string_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_wstring*/
+	break;
+
+/****
+ *STRING_TO_STRING
+ */
+	case function_string_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_string*/
+	break;
+
+/****
+ *STRING_TO_LWORD
+ */
+	case function_string_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_lword*/
+	break;
+
+/****
+ *STRING_TO_UINT
+ */
+	case function_string_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_uint*/
+	break;
+
+/****
+ *STRING_TO_LREAL
+ */
+	case function_string_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_lreal*/
+	break;
+
+/****
+ *STRING_TO_BYTE
+ */
+	case function_string_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_byte*/
+	break;
+
+/****
+ *STRING_TO_USINT
+ */
+	case function_string_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_usint*/
+	break;
+
+/****
+ *STRING_TO_ULINT
+ */
+	case function_string_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_ulint*/
+	break;
+
+/****
+ *STRING_TO_BOOL
+ */
+	case function_string_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_bool*/
+	break;
+
+/****
+ *STRING_TO_TIME
+ */
+	case function_string_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_time*/
+	break;
+
+/****
+ *STRING_TO_INT
+ */
+	case function_string_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_string_to_int*/
+	break;
+
+/****
+ *LWORD_TO_REAL
+ */
+	case function_lword_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_real*/
+	break;
+
+/****
+ *LWORD_TO_SINT
+ */
+	case function_lword_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_sint*/
+	break;
+
+/****
+ *LWORD_TO_LINT
+ */
+	case function_lword_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_lint*/
+	break;
+
+/****
+ *LWORD_TO_DINT
+ */
+	case function_lword_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_dint*/
+	break;
+
+/****
+ *LWORD_TO_DATE
+ */
+	case function_lword_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_date*/
+	break;
+
+/****
+ *LWORD_TO_DWORD
+ */
+	case function_lword_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_dword*/
+	break;
+
+/****
+ *LWORD_TO_DT
+ */
+	case function_lword_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_dt*/
+	break;
+
+/****
+ *LWORD_TO_TOD
+ */
+	case function_lword_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_tod*/
+	break;
+
+/****
+ *LWORD_TO_UDINT
+ */
+	case function_lword_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_udint*/
+	break;
+
+/****
+ *LWORD_TO_WORD
+ */
+	case function_lword_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_word*/
+	break;
+
+/****
+ *LWORD_TO_WSTRING
+ */
+	case function_lword_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_wstring*/
+	break;
+
+/****
+ *LWORD_TO_STRING
+ */
+	case function_lword_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_string*/
+	break;
+
+/****
+ *LWORD_TO_LWORD
+ */
+	case function_lword_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_lword*/
+	break;
+
+/****
+ *LWORD_TO_UINT
+ */
+	case function_lword_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_uint*/
+	break;
+
+/****
+ *LWORD_TO_LREAL
+ */
+	case function_lword_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_lreal*/
+	break;
+
+/****
+ *LWORD_TO_BYTE
+ */
+	case function_lword_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_byte*/
+	break;
+
+/****
+ *LWORD_TO_USINT
+ */
+	case function_lword_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_usint*/
+	break;
+
+/****
+ *LWORD_TO_ULINT
+ */
+	case function_lword_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_ulint*/
+	break;
+
+/****
+ *LWORD_TO_BOOL
+ */
+	case function_lword_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_bool*/
+	break;
+
+/****
+ *LWORD_TO_TIME
+ */
+	case function_lword_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_time*/
+	break;
+
+/****
+ *LWORD_TO_INT
+ */
+	case function_lword_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lword_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lword_to_int*/
+	break;
+
+/****
+ *UINT_TO_REAL
+ */
+	case function_uint_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_real*/
+	break;
+
+/****
+ *UINT_TO_SINT
+ */
+	case function_uint_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_sint*/
+	break;
+
+/****
+ *UINT_TO_LINT
+ */
+	case function_uint_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_lint*/
+	break;
+
+/****
+ *UINT_TO_DINT
+ */
+	case function_uint_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_dint*/
+	break;
+
+/****
+ *UINT_TO_DATE
+ */
+	case function_uint_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_date*/
+	break;
+
+/****
+ *UINT_TO_DWORD
+ */
+	case function_uint_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_dword*/
+	break;
+
+/****
+ *UINT_TO_DT
+ */
+	case function_uint_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_dt*/
+	break;
+
+/****
+ *UINT_TO_TOD
+ */
+	case function_uint_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_tod*/
+	break;
+
+/****
+ *UINT_TO_UDINT
+ */
+	case function_uint_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_udint*/
+	break;
+
+/****
+ *UINT_TO_WORD
+ */
+	case function_uint_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_word*/
+	break;
+
+/****
+ *UINT_TO_WSTRING
+ */
+	case function_uint_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_wstring*/
+	break;
+
+/****
+ *UINT_TO_STRING
+ */
+	case function_uint_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_string*/
+	break;
+
+/****
+ *UINT_TO_LWORD
+ */
+	case function_uint_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_lword*/
+	break;
+
+/****
+ *UINT_TO_UINT
+ */
+	case function_uint_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_uint*/
+	break;
+
+/****
+ *UINT_TO_LREAL
+ */
+	case function_uint_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_lreal*/
+	break;
+
+/****
+ *UINT_TO_BYTE
+ */
+	case function_uint_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_byte*/
+	break;
+
+/****
+ *UINT_TO_USINT
+ */
+	case function_uint_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_usint*/
+	break;
+
+/****
+ *UINT_TO_ULINT
+ */
+	case function_uint_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_ulint*/
+	break;
+
+/****
+ *UINT_TO_BOOL
+ */
+	case function_uint_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_bool*/
+	break;
+
+/****
+ *UINT_TO_TIME
+ */
+	case function_uint_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_time*/
+	break;
+
+/****
+ *UINT_TO_INT
+ */
+	case function_uint_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_int*/
+	break;
+
+/****
+ *LREAL_TO_REAL
+ */
+	case function_lreal_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_real*/
+	break;
+
+/****
+ *LREAL_TO_SINT
+ */
+	case function_lreal_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_sint*/
+	break;
+
+/****
+ *LREAL_TO_LINT
+ */
+	case function_lreal_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_lint*/
+	break;
+
+/****
+ *LREAL_TO_DINT
+ */
+	case function_lreal_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_dint*/
+	break;
+
+/****
+ *LREAL_TO_DATE
+ */
+	case function_lreal_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_date*/
+	break;
+
+/****
+ *LREAL_TO_DWORD
+ */
+	case function_lreal_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_dword*/
+	break;
+
+/****
+ *LREAL_TO_DT
+ */
+	case function_lreal_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_dt*/
+	break;
+
+/****
+ *LREAL_TO_TOD
+ */
+	case function_lreal_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_tod*/
+	break;
+
+/****
+ *LREAL_TO_UDINT
+ */
+	case function_lreal_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_udint*/
+	break;
+
+/****
+ *LREAL_TO_WORD
+ */
+	case function_lreal_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_word*/
+	break;
+
+/****
+ *LREAL_TO_WSTRING
+ */
+	case function_lreal_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_wstring*/
+	break;
+
+/****
+ *LREAL_TO_STRING
+ */
+	case function_lreal_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_string*/
+	break;
+
+/****
+ *LREAL_TO_LWORD
+ */
+	case function_lreal_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_lword*/
+	break;
+
+/****
+ *LREAL_TO_UINT
+ */
+	case function_lreal_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_uint*/
+	break;
+
+/****
+ *LREAL_TO_LREAL
+ */
+	case function_lreal_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_lreal*/
+	break;
+
+/****
+ *LREAL_TO_BYTE
+ */
+	case function_lreal_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_byte*/
+	break;
+
+/****
+ *LREAL_TO_USINT
+ */
+	case function_lreal_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_usint*/
+	break;
+
+/****
+ *LREAL_TO_ULINT
+ */
+	case function_lreal_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_ulint*/
+	break;
+
+/****
+ *LREAL_TO_BOOL
+ */
+	case function_lreal_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_bool*/
+	break;
+
+/****
+ *LREAL_TO_TIME
+ */
+	case function_lreal_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_time*/
+	break;
+
+/****
+ *LREAL_TO_INT
+ */
+	case function_lreal_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lreal_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lreal_to_int*/
+	break;
+
+/****
+ *BYTE_TO_REAL
+ */
+	case function_byte_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_real*/
+	break;
+
+/****
+ *BYTE_TO_SINT
+ */
+	case function_byte_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_sint*/
+	break;
+
+/****
+ *BYTE_TO_LINT
+ */
+	case function_byte_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_lint*/
+	break;
+
+/****
+ *BYTE_TO_DINT
+ */
+	case function_byte_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_dint*/
+	break;
+
+/****
+ *BYTE_TO_DATE
+ */
+	case function_byte_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_date*/
+	break;
+
+/****
+ *BYTE_TO_DWORD
+ */
+	case function_byte_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_dword*/
+	break;
+
+/****
+ *BYTE_TO_DT
+ */
+	case function_byte_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_dt*/
+	break;
+
+/****
+ *BYTE_TO_TOD
+ */
+	case function_byte_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_tod*/
+	break;
+
+/****
+ *BYTE_TO_UDINT
+ */
+	case function_byte_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_udint*/
+	break;
+
+/****
+ *BYTE_TO_WORD
+ */
+	case function_byte_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_word*/
+	break;
+
+/****
+ *BYTE_TO_WSTRING
+ */
+	case function_byte_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_wstring*/
+	break;
+
+/****
+ *BYTE_TO_STRING
+ */
+	case function_byte_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_string*/
+	break;
+
+/****
+ *BYTE_TO_LWORD
+ */
+	case function_byte_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_lword*/
+	break;
+
+/****
+ *BYTE_TO_UINT
+ */
+	case function_byte_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_uint*/
+	break;
+
+/****
+ *BYTE_TO_LREAL
+ */
+	case function_byte_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_lreal*/
+	break;
+
+/****
+ *BYTE_TO_BYTE
+ */
+	case function_byte_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_byte*/
+	break;
+
+/****
+ *BYTE_TO_USINT
+ */
+	case function_byte_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_usint*/
+	break;
+
+/****
+ *BYTE_TO_ULINT
+ */
+	case function_byte_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_ulint*/
+	break;
+
+/****
+ *BYTE_TO_BOOL
+ */
+	case function_byte_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_bool*/
+	break;
+
+/****
+ *BYTE_TO_TIME
+ */
+	case function_byte_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_time*/
+	break;
+
+/****
+ *BYTE_TO_INT
+ */
+	case function_byte_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(byte_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_byte_to_int*/
+	break;
+
+/****
+ *USINT_TO_REAL
+ */
+	case function_usint_to_real :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_real*/
+	break;
+
+/****
+ *USINT_TO_SINT
+ */
+	case function_usint_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_sint*/
+	break;
+
+/****
+ *USINT_TO_LINT
+ */
+	case function_usint_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_lint*/
+	break;
+
+/****
+ *USINT_TO_DINT
+ */
+	case function_usint_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_dint*/
+	break;
+
+/****
+ *USINT_TO_DATE
+ */
+	case function_usint_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_date*/
+	break;
+
+/****
+ *USINT_TO_DWORD
+ */
+	case function_usint_to_dword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_dword*/
+	break;
+
+/****
+ *USINT_TO_DT
+ */
+	case function_usint_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_dt*/
+	break;
+
+/****
+ *USINT_TO_TOD
+ */
+	case function_usint_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_tod*/
+	break;
+
+/****
+ *USINT_TO_UDINT
+ */
+	case function_usint_to_udint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_udint*/
+	break;
+
+/****
+ *USINT_TO_WORD
+ */
+	case function_usint_to_word :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_word*/
+	break;
+
+/****
+ *USINT_TO_WSTRING
+ */
+	case function_usint_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_wstring*/
+	break;
+
+/****
+ *USINT_TO_STRING
+ */
+	case function_usint_to_string :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_string*/
+	break;
+
+/****
+ *USINT_TO_LWORD
+ */
+	case function_usint_to_lword :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_lword*/
+	break;
+
+/****
+ *USINT_TO_UINT
+ */
+	case function_usint_to_uint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_uint*/
+	break;
+
+/****
+ *USINT_TO_LREAL
+ */
+	case function_usint_to_lreal :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_lreal*/
+	break;
+
+/****
+ *USINT_TO_BYTE
+ */
+	case function_usint_to_byte :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_byte*/
+	break;
+
+/****
+ *USINT_TO_USINT
+ */
+	case function_usint_to_usint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_usint*/
+	break;
+
+/****
+ *USINT_TO_ULINT
+ */
+	case function_usint_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_ulint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_bool*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_time*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_to_int*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_real*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_sint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_lint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_dint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_date*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_dword*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_dt*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_tod*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_udint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_word*/
+	break;
+
+/****
+ *ULINT_TO_WSTRING
+ */
+	case function_ulint_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_wstring*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_string*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_lword*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_uint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_lreal*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_byte*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_usint*/
+	break;
+
+/****
+ *ULINT_TO_ULINT
+ */
+	case function_ulint_to_ulint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_ulint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_bool*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_time*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_int*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_real*/
+	break;
+
+/****
+ *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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_sint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_lint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_dint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_date*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_dword*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_dt*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_tod*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_udint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_word*/
+	break;
+
+/****
+ *BOOL_TO_WSTRING
+ */
+	case function_bool_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_wstring*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_string*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_lword*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_uint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_lreal*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_byte*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_usint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_ulint*/
+	break;
+
+/****
+ *BOOL_TO_BOOL
+ */
+	case function_bool_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_bool*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_time*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bool_to_int*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_real*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_sint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_lint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_dint*/
+	break;
+
+/****
+ *TIME_TO_DATE
+ */
+	case function_time_to_date :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_date*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_dword*/
+	break;
+
+/****
+ *TIME_TO_DT
+ */
+	case function_time_to_dt :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_dt*/
+	break;
+
+/****
+ *TIME_TO_TOD
+ */
+	case function_time_to_tod :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_tod*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_udint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_word*/
+	break;
+
+/****
+ *TIME_TO_WSTRING
+ */
+	case function_time_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_wstring*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_string*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_lword*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_uint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_lreal*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_byte*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_usint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_ulint*/
+	break;
+
+/****
+ *TIME_TO_BOOL
+ */
+	case function_time_to_bool :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_bool*/
+	break;
+
+/****
+ *TIME_TO_TIME
+ */
+	case function_time_to_time :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_time*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_time_to_int*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_real*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_sint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_lint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_dint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_date*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_dword*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_dt*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_tod*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_udint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_word*/
+	break;
+
+/****
+ *INT_TO_WSTRING
+ */
+	case function_int_to_wstring :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::wstring_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_wstring*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::string_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_string*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lword_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_lword*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_uint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lreal_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_lreal*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::byte_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_byte*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_usint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_ulint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::bool_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_bool*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_time*/
+	break;
+
+/****
+ *INT_TO_INT
+ */
+	case function_int_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_to_int*/
+	break;
+
+/****
+ *TRUNC
+ */
+	case function_trunc :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_trunc*/
+	break;
+
+/****
+ *BCD_TO_SINT
+ */
+	case function_bcd_to_sint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bcd_to_sint*/
+	break;
+
+/****
+ *BCD_TO_LINT
+ */
+	case function_bcd_to_lint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bcd_to_lint*/
+	break;
+
+/****
+ *BCD_TO_DINT
+ */
+	case function_bcd_to_dint :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bcd_to_dint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::udint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bcd_to_udint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::uint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bcd_to_uint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::usint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bcd_to_usint*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bcd_to_ulint*/
+	break;
+
+/****
+ *BCD_TO_INT
+ */
+	case function_bcd_to_int :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_bcd_to_int*/
+	break;
+
+/****
+ *SINT_TO_BCD
+ */
+	case function_sint_to_bcd :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(sint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_sint_to_bcd*/
+	break;
+
+/****
+ *LINT_TO_BCD
+ */
+	case function_lint_to_bcd :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(lint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_lint_to_bcd*/
+	break;
+
+/****
+ *DINT_TO_BCD
+ */
+	case function_dint_to_bcd :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_dint_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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(udint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_udint_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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_uint_to_bcd*/
+	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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(usint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_usint_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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(ulint_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_ulint_to_bcd*/
+	break;
+
+/****
+ *INT_TO_BCD
+ */
+	case function_int_to_bcd :
+	{
+		symbol_c *last_type_symbol = NULL;
+
+		{
+			identifier_c param_name("IN");
+			/* Get the value from a foo(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(int_type_name_c))
+			{
+		
+				symbol_c * return_type_symbol = &search_constant_type_c::constant_int_type_name;
+				return return_type_symbol;
+				
+			}
+			
+			ERROR;
+		}
+		
+	}/*function_int_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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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_param_value))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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_param_value))
+					{
+				
+						symbol_c * return_type_symbol = last_type_symbol;
+						return return_type_symbol;
+						
+					}
+					
+					ERROR;
+				}
+				
+			}
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(time_type_name_c))
+					{
+				
+						symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+						return return_type_symbol;
+						
+					}
+					
+					ERROR;
+				}
+				
+			}
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(time_type_name_c))
+					{
+				
+						symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+						return return_type_symbol;
+						
+					}
+					
+					ERROR;
+				}
+				
+			}
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(time_type_name_c))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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_param_value))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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_param_value))
+					{
+				
+						symbol_c * return_type_symbol = last_type_symbol;
+						return return_type_symbol;
+						
+					}
+					
+					ERROR;
+				}
+				
+			}
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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_param_value))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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_param_value))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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_param_value))
+					{
+				
+						symbol_c * return_type_symbol = last_type_symbol;
+						return return_type_symbol;
+						
+					}
+					
+					ERROR;
+				}
+				
+			}
+			
+			if (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(date_type_name_c))
+					{
+				
+						symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+						return return_type_symbol;
+						
+					}
+					
+					ERROR;
+				}
+				
+			}
+			
+			if (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(dt_type_name_c))
+					{
+				
+						symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+						return return_type_symbol;
+						
+					}
+					
+					if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+					{
+				
+						symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+						return return_type_symbol;
+						
+					}
+					
+					ERROR;
+				}
+				
+			}
+			
+			if (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+					{
+				
+						symbol_c * return_type_symbol = &search_constant_type_c::time_type_name;
+						return return_type_symbol;
+						
+					}
+					
+					if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+					{
+				
+						symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
+						return return_type_symbol;
+						
+					}
+					
+					ERROR;
+				}
+				
+			}
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(time_type_name_c))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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_param_value))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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_param_value))
+					{
+				
+						symbol_c * return_type_symbol = last_type_symbol;
+						return return_type_symbol;
+						
+					}
+					
+					ERROR;
+				}
+				
+			}
+			
+			if (typeid(*last_type_symbol) == typeid(time_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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_param_value))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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_param_value))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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_param_value))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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_param_value))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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_param_value))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				{
+					identifier_c param_name("N");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *N_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				{
+					identifier_c param_name("N");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *N_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				{
+					identifier_c param_name("N");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *N_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				{
+					identifier_c param_name("N");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *N_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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_param_value))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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_param_value))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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_param_value))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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_param_value))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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_param_value))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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_param_value))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_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_param_value))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *G_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(bool_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN0");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN0_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+							symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+							
+							/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+			symbol_c *MN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+					symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) style call */
+					if (IN_param_value == NULL)
+					  IN_param_value = function_call_param_iterator.next();
+					symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+					last_type_symbol = last_type_symbol && search_expression_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(<param_name> = <param_value>) style call */
+							symbol_c *MX_param_value = function_call_param_iterator.search(&param_name);
+							
+							/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+			symbol_c *K_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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_param_value))
+			{
+		
+				{
+					identifier_c param_name("IN0");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN0_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+							symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+							
+							/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("L");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *L_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("L");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *L_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("L");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *L_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+					{
+				
+						{
+							identifier_c param_name("P");
+							/* Get the value from a foo(<param_name> = <param_value>) style call */
+							symbol_c *P_param_value = function_call_param_iterator.search(&param_name);
+							
+							/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+							{
+						
+								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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(date_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(tod_type_name_c))
+					{
+				
+						symbol_c * return_type_symbol = &search_constant_type_c::dt_type_name;
+						return return_type_symbol;
+						
+					}
+					
+					ERROR;
+				}
+				
+			}
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(string_type_name_c))
+					{
+				
+						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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(string_type_name_c))
+					{
+				
+						{
+							identifier_c param_name("P");
+							/* Get the value from a foo(<param_name> = <param_value>) style call */
+							symbol_c *P_param_value = function_call_param_iterator.search(&param_name);
+							
+							/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+							{
+						
+								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(<param_name> = <param_value>) style call */
+			symbol_c *IN_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) style call */
+			if (IN_param_value == NULL)
+			  IN_param_value = function_call_param_iterator.next();
+			symbol_c *IN_type_symbol = search_expression_type->get_type(IN_param_value);
+			last_type_symbol = last_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
+			
+			if (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("L");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *L_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+					{
+				
+						{
+							identifier_c param_name("P");
+							/* Get the value from a foo(<param_name> = <param_value>) style call */
+							symbol_c *P_param_value = function_call_param_iterator.search(&param_name);
+							
+							/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+							{
+						
+								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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(string_type_name_c))
+					{
+				
+						{
+							identifier_c param_name("L");
+							/* Get the value from a foo(<param_name> = <param_value>) style call */
+							symbol_c *L_param_value = function_call_param_iterator.search(&param_name);
+							
+							/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+							{
+						
+								{
+									identifier_c param_name("P");
+									/* Get the value from a foo(<param_name> = <param_value>) style call */
+									symbol_c *P_param_value = function_call_param_iterator.search(&param_name);
+									
+									/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(uint_type_name_c))
+									{
+								
+										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(<param_name> = <param_value>) style call */
+			symbol_c *IN1_param_value = function_call_param_iterator.search(&param_name);
+			
+			/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(string_type_name_c))
+			{
+		
+				{
+					identifier_c param_name("IN2");
+					/* Get the value from a foo(<param_name> = <param_value>) style call */
+					symbol_c *IN2_param_value = function_call_param_iterator.search(&param_name);
+					
+					/* Get the value from a foo(<param_value>) 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 (typeid(*last_type_symbol) == typeid(string_type_name_c))
+					{
+				
+						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;