Merge with 01068ccb73b202b2872d4117ad01984bac956cbb
authorlaurent
Thu, 08 Sep 2011 20:25:00 +0200
changeset 375 7a11f9e9e703
parent 349 b826f13c260e (current diff)
parent 374 01068ccb73b2 (diff)
child 376 7dcbd8418771
Merge with 01068ccb73b202b2872d4117ad01984bac956cbb
Makefile
Makefile.CYGWIN_NT-5.1
Makefile.CYGWIN_NT-6.0
Makefile.Darwin
Makefile.Linux
Makefile.MINGW32_NT-5.1
absyntax/Makefile
absyntax_utils/Makefile
absyntax_utils/Makefile.am
absyntax_utils/Makefile.in
absyntax_utils/absyntax_utils.hh
absyntax_utils/search_type_code.c
aclocal.m4
configure
lib/create_standard_function_txt.sh
lib/iec_std_lib.h
lib/iec_std_lib_generated.h
lib/ieclib.txt
stage1_2/Makefile
stage1_2/iec.flex
stage1_2/iec.y
stage3/Makefile
stage4/Makefile
stage4/generate_c/Makefile
stage4/generate_c/generate_c_st.cc
stage4/generate_c/il_code_gen.c
stage4/generate_c/st_code_gen.c
stage4/generate_iec/Makefile
--- a/.hgignore	Wed Sep 07 19:28:10 2011 +0200
+++ b/.hgignore	Thu Sep 08 20:25:00 2011 +0200
@@ -1,12 +1,25 @@
+syntax: glob
+
 .project
+*~
+*.a
+.dep
+*.Po
+autom4te.cache
+Makefile
+config.log
+stamp-h1
+config.status
+
+
 
 syntax: regexp
+
 \.o$
-syntax: regexp
 ^iec2c$
-syntax: regexp
 ^iec2iec$
-syntax: regexp
 \.depend$
-syntax: regexp
-^stage1_2/iec\.(y|flex)\..*$
+^stage1_2/iec_bison.cc
+^stage1_2/iec_bison.h
+^stage1_2/iec_flex.cc
+^config/config.h
\ No newline at end of file
--- a/Makefile	Wed Sep 07 19:28:10 2011 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,93 +0,0 @@
-# matiec - a compiler for the programming languages defined in IEC 61131-3
-#
-# Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)
-# Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-# include the system specific Makefile
-include Makefile.$(shell uname)
-
-default: all
-
-all: iec2c iec2iec
-
-install: all
-	install -d $(INSTALL_PREDIR)/$(INSTALL_BINDIR)/ 
-	install -d $(INSTALL_PREDIR)/$(IECLIBDIR)/
-	install iec2c    $(INSTALL_PREDIR)/$(INSTALL_BINDIR)/
-	install lib/*.txt $(INSTALL_PREDIR)/$(IECLIBDIR)/
-#	install iec2iec   $(INSTALL_PREDIR)/$(INSTALL_BINDIR)/
-
-
-uninstall:
-	rm -f $(INSTALL_PREDIR)/$(INSTALL_BINDIR)/iec2c
-	rm -f $(INSTALL_PREDIR)/$(INSTALL_BINDIR)/iec2iec
-	for ff in `cd lib; ls *.txt; cd ..` do echo $$ff done
-#	for ff in `cd lib; ls *.txt; cd ..` do rm -f $(INSTALL_PREDIR)/$(IECLIBDIR)/$$ff done
-
-
-clean:
-	-rm -f iec2iec iec2c *.o absyntax/*.o
-	echo > Makefile.depend
-# make something everywhere (ie, in all Makefiles that have that target)
-	find . -depth -mindepth 2 -maxdepth 2 -name Makefile | sed 's/Makefile//g' | xargs -I {} $(MAKE) -C{} clean
-
-CXXFLAGS += -I.
-
-LIBS  = absyntax/absyntax.o absyntax/visitor.o
-LIBS += stage1_2/stage1_2.o stage1_2/iec.y.o stage1_2/iec.flex.o
-LIBS += stage3/stage3.o
-LIBS += stage3/visit_expression_type.o
-LIBS += absyntax_utils/absyntax_utils.o
-LIBS += absyntax_utils/search_expression_type.o
-LIBS += absyntax_utils/decompose_var_instance_name.o
-LIBS += absyntax_utils/case_element_iterator.o
-LIBS += absyntax_utils/function_call_iterator.o
-LIBS += absyntax_utils/function_call_param_iterator.o
-LIBS += absyntax_utils/function_param_iterator.o
-LIBS += absyntax_utils/search_base_type.o
-LIBS += absyntax_utils/search_constant_type.o
-LIBS += absyntax_utils/search_fb_instance_decl.o
-LIBS += absyntax_utils/search_fb_typedecl.o
-LIBS += absyntax_utils/search_varfb_instance_type.o
-LIBS += absyntax_utils/search_var_instance_decl.o
-LIBS += absyntax_utils/spec_init_separator.o
-LIBS += absyntax_utils/type_initial_value.o
-LIBS += absyntax_utils/add_en_eno_param_decl.o
-LIBS += absyntax_utils/get_sizeof_datatype.o
-LIBS += absyntax_utils/get_function_type.o
-
-
-
-iec2c: main.o stage4/generate_c/generate_c.o stage4/stage4.o $(LIBS)
-	$(CXX) -o iec2c main.o stage4/stage4.o stage4/generate_c/generate_c.o $(LIBS)
-
-
-iec2iec: main.o stage4/generate_iec/generate_iec.o stage4/stage4.o $(LIBS)
-	$(CXX) -o iec2iec main.o stage4/stage4.o stage4/generate_iec/generate_iec.o $(LIBS)
-
-
-#how to make things in subdirectories etc
-../% /% absyntax/% stage1_2/% stage3/% stage4/% util/%:
-	$(MAKE) -C $(@D) $(@F)
-
-Makefile.depend depend:
-	$(CXX) -MM -MG -I. *.cc \
-	  | sed 's/:/ Makefile.depend:/' > Makefile.depend
-
-include Makefile.depend
-
-
-
--- a/Makefile.CYGWIN_NT-5.1	Wed Sep 07 19:28:10 2011 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,34 +0,0 @@
-# matiec - a compiler for the programming languages defined in IEC 61131-3
-#
-# Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)
-# Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-CXX = g++ -mno-cygwin
-
-#get warnings, debugging information and optimization
-CFLAGS  = -Wall -Wpointer-arith -Wwrite-strings
-# CFLAGS += -Werror
-# CFLAGS += -ggdb
-#CFLAGS += -O3 -funroll-loops
-# Note: if the optimizer crashes, we'll leave out the -O3 for those files
-
-#get warnings, debugging information and optimization
-#CXXFLAGS  = -Wall -pedantic -Wpointer-arith -Wwrite-strings
-#CXXFLAGS += -ggdb
-#CXXFLAGS += -O3 -funroll-loops
-CXXFLAGS  = $(CFLAGS)
-
-IECLIBDIR=lib
--- a/Makefile.CYGWIN_NT-6.0	Wed Sep 07 19:28:10 2011 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,35 +0,0 @@
-# matiec - a compiler for the programming languages defined in IEC 61131-3
-#
-# Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)
-# Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#CXX = i686-mingw32-c++ 
-CXX = g++ -mno-cygwin
-
-#get warnings, debugging information and optimization
-CFLAGS  = -Wall -pedantic -Wpointer-arith -Wwrite-strings
-# CFLAGS += -Werror
-CFLAGS += -ggdb
-#CFLAGS += -O3 -funroll-loops
-# Note: if the optimizer crashes, we'll leave out the -O3 for those files
-
-#get warnings, debugging information and optimization
-#CXXFLAGS  = -Wall -pedantic -Wpointer-arith -Wwrite-strings
-#CXXFLAGS += -ggdb
-#CXXFLAGS += -O3 -funroll-loops
-CXXFLAGS  = $(CFLAGS)
-
-IECLIBDIR=lib
--- a/Makefile.Darwin	Wed Sep 07 19:28:10 2011 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,34 +0,0 @@
-# matiec - a compiler for the programming languages defined in IEC 61131-3
-#
-# Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)
-# Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-CXX = g++ 
-
-#get warnings, debugging information and optimization
-CFLAGS  = -Wall -Wpointer-arith -Wwrite-strings
-# CFLAGS += -Werror
-CFLAGS += -ggdb
-#CFLAGS += -O3 -funroll-loops
-# Note: if the optimizer crashes, we'll leave out the -O3 for those files
-
-#get warnings, debugging information and optimization
-#CXXFLAGS  = -Wall -pedantic -Wpointer-arith -Wwrite-strings
-#CXXFLAGS += -ggdb
-#CXXFLAGS += -O3 -funroll-loops
-CXXFLAGS  = $(CFLAGS)
-
-IECLIBDIR=lib
--- a/Makefile.Linux	Wed Sep 07 19:28:10 2011 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,35 +0,0 @@
-# matiec - a compiler for the programming languages defined in IEC 61131-3
-#
-# Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)
-# Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#CXX = i686-mingw32-c++ 
-CXX = g++ 
-
-#get warnings, debugging information and optimization
-CFLAGS  = -Wall -Wpointer-arith -Wwrite-strings
-# CFLAGS += -Werror
-CFLAGS += -ggdb
-#CFLAGS += -O3 -funroll-loops
-# Note: if the optimizer crashes, we'll leave out the -O3 for those files
-
-#get warnings, debugging information and optimization
-#CXXFLAGS  = -Wall -pedantic -Wpointer-arith -Wwrite-strings
-#CXXFLAGS += -ggdb
-#CXXFLAGS += -O3 -funroll-loops
-CXXFLAGS  = $(CFLAGS)
-
-IECLIBDIR=lib
--- a/Makefile.MINGW32_NT-5.1	Wed Sep 07 19:28:10 2011 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,35 +0,0 @@
-# matiec - a compiler for the programming languages defined in IEC 61131-3
-#
-# Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)
-# Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#CXX = i686-mingw32-c++ 
-CXX = g++
-
-#get warnings, debugging information and optimization
-CFLAGS  = -Wall -pedantic -Wpointer-arith -Wwrite-strings
-# CFLAGS += -Werror
-CFLAGS += -ggdb
-#CFLAGS += -O3 -funroll-loops
-# Note: if the optimizer crashes, we'll leave out the -O3 for those files
-
-#get warnings, debugging information and optimization
-#CXXFLAGS  = -Wall -pedantic -Wpointer-arith -Wwrite-strings
-#CXXFLAGS += -ggdb
-#CXXFLAGS += -O3 -funroll-loops
-CXXFLAGS  = $(CFLAGS)
-
-IECLIBDIR=lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Makefile.am	Thu Sep 08 20:25:00 2011 +0200
@@ -0,0 +1,27 @@
+include common.mk
+
+bin_PROGRAMS = iec2c iec2iec
+
+SUBDIRS = absyntax absyntax_utils stage1_2 stage3 stage4 
+
+ACLOCAL_AMFLAGS=-I config
+
+HGVERSION= $(shell hg -R $(top_srcdir) parents --template '{node|short}' 2> /dev/null || grep node $(top_srcdir)/.hg_archival.txt 2> /dev/null || true )
+AM_CXXFLAGS += -DHGVERSION="\"${HGVERSION}\""
+
+iec2c_LDADD = stage1_2/libstage1_2.a \
+	stage3/libstage3.a \
+	stage4/generate_c/libstage4_c.a \
+	absyntax/libabsyntax.a \
+	absyntax_utils/libabsyntax_utils.a 
+
+iec2iec_LDADD = stage1_2/libstage1_2.a \
+	stage3/libstage3.a \
+	stage4/generate_iec/libstage4_iec.a \
+	absyntax/libabsyntax.a \
+	absyntax_utils/libabsyntax_utils.a 
+
+iec2c_SOURCES = main.cc
+
+iec2iec_SOURCES = main.cc
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Makefile.in	Thu Sep 08 20:25:00 2011 +0200
@@ -0,0 +1,801 @@
+# Makefile.in generated by automake 1.11.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation,
+# Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+DIST_COMMON = $(am__configure_deps) $(srcdir)/Makefile.am \
+	$(srcdir)/Makefile.in $(srcdir)/common.mk \
+	$(top_srcdir)/config/config.h.in $(top_srcdir)/configure \
+	COPYING config/INSTALL config/depcomp config/install-sh \
+	config/ltmain.sh config/missing config/ylwrap
+bin_PROGRAMS = iec2c$(EXEEXT) iec2iec$(EXEEXT)
+subdir = .
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
+ configure.lineno config.status.lineno
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__installdirs = "$(DESTDIR)$(bindir)"
+PROGRAMS = $(bin_PROGRAMS)
+am_iec2c_OBJECTS = main.$(OBJEXT)
+iec2c_OBJECTS = $(am_iec2c_OBJECTS)
+iec2c_DEPENDENCIES = stage1_2/libstage1_2.a stage3/libstage3.a \
+	stage4/generate_c/libstage4_c.a absyntax/libabsyntax.a \
+	absyntax_utils/libabsyntax_utils.a
+am_iec2iec_OBJECTS = main.$(OBJEXT)
+iec2iec_OBJECTS = $(am_iec2iec_OBJECTS)
+iec2iec_DEPENDENCIES = stage1_2/libstage1_2.a stage3/libstage3.a \
+	stage4/generate_iec/libstage4_iec.a absyntax/libabsyntax.a \
+	absyntax_utils/libabsyntax_utils.a
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)/config
+depcomp = $(SHELL) $(top_srcdir)/config/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+CXXLD = $(CXX)
+CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
+	-o $@
+SOURCES = $(iec2c_SOURCES) $(iec2iec_SOURCES)
+DIST_SOURCES = $(iec2c_SOURCES) $(iec2iec_SOURCES)
+RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \
+	html-recursive info-recursive install-data-recursive \
+	install-dvi-recursive install-exec-recursive \
+	install-html-recursive install-info-recursive \
+	install-pdf-recursive install-ps-recursive install-recursive \
+	installcheck-recursive installdirs-recursive pdf-recursive \
+	ps-recursive uninstall-recursive
+RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive	\
+  distclean-recursive maintainer-clean-recursive
+AM_RECURSIVE_TARGETS = $(RECURSIVE_TARGETS:-recursive=) \
+	$(RECURSIVE_CLEAN_TARGETS:-recursive=) tags TAGS ctags CTAGS \
+	distdir dist dist-all distcheck
+ETAGS = etags
+CTAGS = ctags
+DIST_SUBDIRS = $(SUBDIRS)
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+distdir = $(PACKAGE)-$(VERSION)
+top_distdir = $(distdir)
+am__remove_distdir = \
+  { test ! -d "$(distdir)" \
+    || { find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \
+         && rm -fr "$(distdir)"; }; }
+am__relativize = \
+  dir0=`pwd`; \
+  sed_first='s,^\([^/]*\)/.*$$,\1,'; \
+  sed_rest='s,^[^/]*/*,,'; \
+  sed_last='s,^.*/\([^/]*\)$$,\1,'; \
+  sed_butlast='s,/*[^/]*$$,,'; \
+  while test -n "$$dir1"; do \
+    first=`echo "$$dir1" | sed -e "$$sed_first"`; \
+    if test "$$first" != "."; then \
+      if test "$$first" = ".."; then \
+        dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
+        dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
+      else \
+        first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
+        if test "$$first2" = "$$first"; then \
+          dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
+        else \
+          dir2="../$$dir2"; \
+        fi; \
+        dir0="$$dir0"/"$$first"; \
+      fi; \
+    fi; \
+    dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
+  done; \
+  reldir="$$dir2"
+DIST_ARCHIVES = $(distdir).tar.gz
+GZIP_ENV = --best
+distuninstallcheck_listfiles = find . -type f -print
+distcleancheck_listfiles = find . -type f -print
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LEX = @LEX@
+LEXLIB = @LEXLIB@
+LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MKDIR_P = @MKDIR_P@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+YACC = @YACC@
+YFLAGS = @YFLAGS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build_alias = @build_alias@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host_alias = @host_alias@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CXXFLAGS = -g -Wall -Wpointer-arith -Wwrite-strings -Wno-unused \
+	-DHGVERSION="\"${HGVERSION}\""
+SUBDIRS = absyntax absyntax_utils stage1_2 stage3 stage4 
+ACLOCAL_AMFLAGS = -I config
+HGVERSION = $(shell hg -R $(top_srcdir) parents --template '{node|short}' 2> /dev/null || grep node $(top_srcdir)/.hg_archival.txt 2> /dev/null || true )
+iec2c_LDADD = stage1_2/libstage1_2.a \
+	stage3/libstage3.a \
+	stage4/generate_c/libstage4_c.a \
+	absyntax/libabsyntax.a \
+	absyntax_utils/libabsyntax_utils.a 
+
+iec2iec_LDADD = stage1_2/libstage1_2.a \
+	stage3/libstage3.a \
+	stage4/generate_iec/libstage4_iec.a \
+	absyntax/libabsyntax.a \
+	absyntax_utils/libabsyntax_utils.a 
+
+iec2c_SOURCES = main.cc
+iec2iec_SOURCES = main.cc
+all: all-recursive
+
+.SUFFIXES:
+.SUFFIXES: .cc .o .obj
+am--refresh:
+	@:
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(srcdir)/common.mk $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \
+	      $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    echo ' $(SHELL) ./config.status'; \
+	    $(SHELL) ./config.status;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	$(SHELL) ./config.status --recheck
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	$(am__cd) $(srcdir) && $(AUTOCONF)
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	$(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
+$(am__aclocal_m4_deps):
+
+config/config.h: config/stamp-h1
+	@if test ! -f $@; then \
+	  rm -f config/stamp-h1; \
+	  $(MAKE) $(AM_MAKEFLAGS) config/stamp-h1; \
+	else :; fi
+
+config/stamp-h1: $(top_srcdir)/config/config.h.in $(top_builddir)/config.status
+	@rm -f config/stamp-h1
+	cd $(top_builddir) && $(SHELL) ./config.status config/config.h
+$(top_srcdir)/config/config.h.in:  $(am__configure_deps) 
+	($(am__cd) $(top_srcdir) && $(AUTOHEADER))
+	rm -f config/stamp-h1
+	touch $@
+
+distclean-hdr:
+	-rm -f config/config.h config/stamp-h1
+install-binPROGRAMS: $(bin_PROGRAMS)
+	@$(NORMAL_INSTALL)
+	test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)"
+	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+	for p in $$list; do echo "$$p $$p"; done | \
+	sed 's/$(EXEEXT)$$//' | \
+	while read p p1; do if test -f $$p; \
+	  then echo "$$p"; echo "$$p"; else :; fi; \
+	done | \
+	sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \
+	    -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+	sed 'N;N;N;s,\n, ,g' | \
+	$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+	  { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+	    if ($$2 == $$4) files[d] = files[d] " " $$1; \
+	    else { print "f", $$3 "/" $$4, $$1; } } \
+	  END { for (d in files) print "f", d, files[d] }' | \
+	while read type dir files; do \
+	    if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+	    test -z "$$files" || { \
+	      echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+	      $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+	    } \
+	; done
+
+uninstall-binPROGRAMS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+	files=`for p in $$list; do echo "$$p"; done | \
+	  sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+	      -e 's/$$/$(EXEEXT)/' `; \
+	test -n "$$list" || exit 0; \
+	echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+	cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+	-test -z "$(bin_PROGRAMS)" || rm -f $(bin_PROGRAMS)
+iec2c$(EXEEXT): $(iec2c_OBJECTS) $(iec2c_DEPENDENCIES) 
+	@rm -f iec2c$(EXEEXT)
+	$(CXXLINK) $(iec2c_OBJECTS) $(iec2c_LDADD) $(LIBS)
+iec2iec$(EXEEXT): $(iec2iec_OBJECTS) $(iec2iec_DEPENDENCIES) 
+	@rm -f iec2iec$(EXEEXT)
+	$(CXXLINK) $(iec2iec_OBJECTS) $(iec2iec_LDADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/main.Po@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@	$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@	$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+# This directory's subdirectories are mostly independent; you can cd
+# into them and run `make' without going through this Makefile.
+# To change the values of `make' variables: instead of editing Makefiles,
+# (1) if the variable is set in `config.status', edit `config.status'
+#     (which will cause the Makefiles to be regenerated when you run `make');
+# (2) otherwise, pass the desired values on the `make' command line.
+$(RECURSIVE_TARGETS):
+	@fail= failcom='exit 1'; \
+	for f in x $$MAKEFLAGS; do \
+	  case $$f in \
+	    *=* | --[!k]*);; \
+	    *k*) failcom='fail=yes';; \
+	  esac; \
+	done; \
+	dot_seen=no; \
+	target=`echo $@ | sed s/-recursive//`; \
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  echo "Making $$target in $$subdir"; \
+	  if test "$$subdir" = "."; then \
+	    dot_seen=yes; \
+	    local_target="$$target-am"; \
+	  else \
+	    local_target="$$target"; \
+	  fi; \
+	  ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+	  || eval $$failcom; \
+	done; \
+	if test "$$dot_seen" = "no"; then \
+	  $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
+	fi; test -z "$$fail"
+
+$(RECURSIVE_CLEAN_TARGETS):
+	@fail= failcom='exit 1'; \
+	for f in x $$MAKEFLAGS; do \
+	  case $$f in \
+	    *=* | --[!k]*);; \
+	    *k*) failcom='fail=yes';; \
+	  esac; \
+	done; \
+	dot_seen=no; \
+	case "$@" in \
+	  distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
+	  *) list='$(SUBDIRS)' ;; \
+	esac; \
+	rev=''; for subdir in $$list; do \
+	  if test "$$subdir" = "."; then :; else \
+	    rev="$$subdir $$rev"; \
+	  fi; \
+	done; \
+	rev="$$rev ."; \
+	target=`echo $@ | sed s/-recursive//`; \
+	for subdir in $$rev; do \
+	  echo "Making $$target in $$subdir"; \
+	  if test "$$subdir" = "."; then \
+	    local_target="$$target-am"; \
+	  else \
+	    local_target="$$target"; \
+	  fi; \
+	  ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
+	  || eval $$failcom; \
+	done && test -z "$$fail"
+tags-recursive:
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
+	done
+ctags-recursive:
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \
+	done
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS: tags-recursive $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	set x; \
+	here=`pwd`; \
+	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
+	  include_option=--etags-include; \
+	  empty_fix=.; \
+	else \
+	  include_option=--include; \
+	  empty_fix=; \
+	fi; \
+	list='$(SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    test ! -f $$subdir/TAGS || \
+	      set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
+	  fi; \
+	done; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: CTAGS
+CTAGS: ctags-recursive $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	$(am__remove_distdir)
+	test -d "$(distdir)" || mkdir "$(distdir)"
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+	@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    test -d "$(distdir)/$$subdir" \
+	    || $(MKDIR_P) "$(distdir)/$$subdir" \
+	    || exit 1; \
+	  fi; \
+	done
+	@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
+	  if test "$$subdir" = .; then :; else \
+	    dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
+	    $(am__relativize); \
+	    new_distdir=$$reldir; \
+	    dir1=$$subdir; dir2="$(top_distdir)"; \
+	    $(am__relativize); \
+	    new_top_distdir=$$reldir; \
+	    echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
+	    echo "     am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
+	    ($(am__cd) $$subdir && \
+	      $(MAKE) $(AM_MAKEFLAGS) \
+	        top_distdir="$$new_top_distdir" \
+	        distdir="$$new_distdir" \
+		am__remove_distdir=: \
+		am__skip_length_check=: \
+		am__skip_mode_fix=: \
+	        distdir) \
+	      || exit 1; \
+	  fi; \
+	done
+	-test -n "$(am__skip_mode_fix)" \
+	|| find "$(distdir)" -type d ! -perm -755 \
+		-exec chmod u+rwx,go+rx {} \; -o \
+	  ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
+	  ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
+	  ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
+	|| chmod -R a+r "$(distdir)"
+dist-gzip: distdir
+	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
+	$(am__remove_distdir)
+
+dist-bzip2: distdir
+	tardir=$(distdir) && $(am__tar) | bzip2 -9 -c >$(distdir).tar.bz2
+	$(am__remove_distdir)
+
+dist-lzma: distdir
+	tardir=$(distdir) && $(am__tar) | lzma -9 -c >$(distdir).tar.lzma
+	$(am__remove_distdir)
+
+dist-xz: distdir
+	tardir=$(distdir) && $(am__tar) | xz -c >$(distdir).tar.xz
+	$(am__remove_distdir)
+
+dist-tarZ: distdir
+	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
+	$(am__remove_distdir)
+
+dist-shar: distdir
+	shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
+	$(am__remove_distdir)
+
+dist-zip: distdir
+	-rm -f $(distdir).zip
+	zip -rq $(distdir).zip $(distdir)
+	$(am__remove_distdir)
+
+dist dist-all: distdir
+	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
+	$(am__remove_distdir)
+
+# This target untars the dist file and tries a VPATH configuration.  Then
+# it guarantees that the distribution is self-contained by making another
+# tarfile.
+distcheck: dist
+	case '$(DIST_ARCHIVES)' in \
+	*.tar.gz*) \
+	  GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\
+	*.tar.bz2*) \
+	  bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
+	*.tar.lzma*) \
+	  lzma -dc $(distdir).tar.lzma | $(am__untar) ;;\
+	*.tar.xz*) \
+	  xz -dc $(distdir).tar.xz | $(am__untar) ;;\
+	*.tar.Z*) \
+	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
+	*.shar.gz*) \
+	  GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\
+	*.zip*) \
+	  unzip $(distdir).zip ;;\
+	esac
+	chmod -R a-w $(distdir); chmod a+w $(distdir)
+	mkdir $(distdir)/_build
+	mkdir $(distdir)/_inst
+	chmod a-w $(distdir)
+	test -d $(distdir)/_build || exit 0; \
+	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
+	  && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
+	  && am__cwd=`pwd` \
+	  && $(am__cd) $(distdir)/_build \
+	  && ../configure --srcdir=.. --prefix="$$dc_install_base" \
+	    $(DISTCHECK_CONFIGURE_FLAGS) \
+	  && $(MAKE) $(AM_MAKEFLAGS) \
+	  && $(MAKE) $(AM_MAKEFLAGS) dvi \
+	  && $(MAKE) $(AM_MAKEFLAGS) check \
+	  && $(MAKE) $(AM_MAKEFLAGS) install \
+	  && $(MAKE) $(AM_MAKEFLAGS) installcheck \
+	  && $(MAKE) $(AM_MAKEFLAGS) uninstall \
+	  && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
+	        distuninstallcheck \
+	  && chmod -R a-w "$$dc_install_base" \
+	  && ({ \
+	       (cd ../.. && umask 077 && mkdir "$$dc_destdir") \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
+	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
+	            distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
+	      } || { rm -rf "$$dc_destdir"; exit 1; }) \
+	  && rm -rf "$$dc_destdir" \
+	  && $(MAKE) $(AM_MAKEFLAGS) dist \
+	  && rm -rf $(DIST_ARCHIVES) \
+	  && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \
+	  && cd "$$am__cwd" \
+	  || exit 1
+	$(am__remove_distdir)
+	@(echo "$(distdir) archives ready for distribution: "; \
+	  list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
+	  sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'
+distuninstallcheck:
+	@$(am__cd) '$(distuninstallcheck_dir)' \
+	&& test `$(distuninstallcheck_listfiles) | wc -l` -le 1 \
+	   || { echo "ERROR: files left after uninstall:" ; \
+	        if test -n "$(DESTDIR)"; then \
+	          echo "  (check DESTDIR support)"; \
+	        fi ; \
+	        $(distuninstallcheck_listfiles) ; \
+	        exit 1; } >&2
+distcleancheck: distclean
+	@if test '$(srcdir)' = . ; then \
+	  echo "ERROR: distcleancheck can only run from a VPATH build" ; \
+	  exit 1 ; \
+	fi
+	@test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
+	  || { echo "ERROR: files left in build directory after distclean:" ; \
+	       $(distcleancheck_listfiles) ; \
+	       exit 1; } >&2
+check-am: all-am
+check: check-recursive
+all-am: Makefile $(PROGRAMS)
+installdirs: installdirs-recursive
+installdirs-am:
+	for dir in "$(DESTDIR)$(bindir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-recursive
+install-exec: install-exec-recursive
+install-data: install-data-recursive
+uninstall: uninstall-recursive
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-recursive
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-recursive
+
+clean-am: clean-binPROGRAMS clean-generic mostlyclean-am
+
+distclean: distclean-recursive
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-hdr distclean-tags
+
+dvi: dvi-recursive
+
+dvi-am:
+
+html: html-recursive
+
+html-am:
+
+info: info-recursive
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-recursive
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS
+
+install-html: install-html-recursive
+
+install-html-am:
+
+install-info: install-info-recursive
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-recursive
+
+install-pdf-am:
+
+install-ps: install-ps-recursive
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-recursive
+	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
+	-rm -rf $(top_srcdir)/autom4te.cache
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-recursive
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic
+
+pdf: pdf-recursive
+
+pdf-am:
+
+ps: ps-recursive
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS
+
+.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) ctags-recursive \
+	install-am install-strip tags-recursive
+
+.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \
+	all all-am am--refresh check check-am clean clean-binPROGRAMS \
+	clean-generic ctags ctags-recursive dist dist-all dist-bzip2 \
+	dist-gzip dist-lzma dist-shar dist-tarZ dist-xz dist-zip \
+	distcheck distclean distclean-compile distclean-generic \
+	distclean-hdr distclean-tags distcleancheck distdir \
+	distuninstallcheck dvi dvi-am html html-am info info-am \
+	install install-am install-binPROGRAMS install-data \
+	install-data-am install-dvi install-dvi-am install-exec \
+	install-exec-am install-html install-html-am install-info \
+	install-info-am install-man install-pdf install-pdf-am \
+	install-ps install-ps-am install-strip installcheck \
+	installcheck-am installdirs installdirs-am maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-compile \
+	mostlyclean-generic pdf pdf-am ps ps-am tags tags-recursive \
+	uninstall uninstall-am uninstall-binPROGRAMS
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/README.build	Thu Sep 08 20:25:00 2011 +0200
@@ -0,0 +1,40 @@
+
+Compile/Build 
+=============
+
+1) Compiling under Linux
+------------------------
+$ ./configure
+$ make
+
+
+2) Cross-Compiling under Linux, for Windows
+-------------------------------------------
+$ ./configure  --host=i586-pc-mingw32
+$ make
+
+
+
+
+
+Maintaining the Build Environment
+=================================
+-> Add new files to Makefile.am or add a new makefile
+$ autoreconf
+
+
+-> Prepare clean project
+$ make distclean
+
+
+
+-> Remember to add these files to your .hgignore
+	Makefile
+	config.*
+	*.a
+	.deps
+
+
+-> Send me TODO list to complete build system.
+	matteo.facchinetti@sirius-es.it
+
--- a/absyntax/Makefile	Wed Sep 07 19:28:10 2011 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,52 +0,0 @@
-# matiec - a compiler for the programming languages defined in IEC 61131-3
-#
-# Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)
-# Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-# include the system specific Makefile
-include ../Makefile.$(shell uname)
-
-
-
-
-default: all
-
-all: absyntax.o visitor.o
-
-clean:
-	rm -f *.o
-
-
-#get warnings, debugging information and optimization
-#CXXFLAGS  = -Wall -pedantic -Wpointer-arith -Wwrite-strings
-# CXXFLAGS += -Werror
-
-#CXXFLAGS += -ggdb -O3 -funroll-loops
-# Note: if the optimizer crashes, we'll leave out the -O3 for those files
-
-CXXFLAGS += -I. -I../* -I../../absyntax
-
-
-
-#how to make things in subdirectories etc
-../% /% absyntax/% stage1_2/% stage3/% stage4/% util/%:
-	        $(MAKE) -C $(@D) $(@F)
-
-Makefile.depend depend:
-	$(CXX) -MM -MG -I. *.cc \
-	  | sed 's/:/ Makefile.depend:/' > Makefile.depend
-
-include Makefile.depend
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/absyntax/Makefile.am	Thu Sep 08 20:25:00 2011 +0200
@@ -0,0 +1,8 @@
+include ../common.mk
+
+lib_LIBRARIES = libabsyntax.a
+
+libabsyntax_a_SOURCES = \
+	absyntax.cc \
+	visitor.cc
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/absyntax/Makefile.in	Thu Sep 08 20:25:00 2011 +0200
@@ -0,0 +1,487 @@
+# Makefile.in generated by automake 1.11.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation,
+# Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+DIST_COMMON = $(srcdir)/../common.mk $(srcdir)/Makefile.am \
+	$(srcdir)/Makefile.in
+subdir = absyntax
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__installdirs = "$(DESTDIR)$(libdir)"
+LIBRARIES = $(lib_LIBRARIES)
+AR = ar
+ARFLAGS = cru
+libabsyntax_a_AR = $(AR) $(ARFLAGS)
+libabsyntax_a_LIBADD =
+am_libabsyntax_a_OBJECTS = absyntax.$(OBJEXT) visitor.$(OBJEXT)
+libabsyntax_a_OBJECTS = $(am_libabsyntax_a_OBJECTS)
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)/config
+depcomp = $(SHELL) $(top_srcdir)/config/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+CXXLD = $(CXX)
+CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
+	-o $@
+SOURCES = $(libabsyntax_a_SOURCES)
+DIST_SOURCES = $(libabsyntax_a_SOURCES)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LEX = @LEX@
+LEXLIB = @LEXLIB@
+LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MKDIR_P = @MKDIR_P@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+YACC = @YACC@
+YFLAGS = @YFLAGS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build_alias = @build_alias@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host_alias = @host_alias@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CXXFLAGS = -g -Wall -Wpointer-arith -Wwrite-strings -Wno-unused 
+lib_LIBRARIES = libabsyntax.a
+libabsyntax_a_SOURCES = \
+	absyntax.cc \
+	visitor.cc
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .o .obj
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(srcdir)/../common.mk $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign absyntax/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign absyntax/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+install-libLIBRARIES: $(lib_LIBRARIES)
+	@$(NORMAL_INSTALL)
+	test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)"
+	@list='$(lib_LIBRARIES)'; test -n "$(libdir)" || list=; \
+	list2=; for p in $$list; do \
+	  if test -f $$p; then \
+	    list2="$$list2 $$p"; \
+	  else :; fi; \
+	done; \
+	test -z "$$list2" || { \
+	  echo " $(INSTALL_DATA) $$list2 '$(DESTDIR)$(libdir)'"; \
+	  $(INSTALL_DATA) $$list2 "$(DESTDIR)$(libdir)" || exit $$?; }
+	@$(POST_INSTALL)
+	@list='$(lib_LIBRARIES)'; test -n "$(libdir)" || list=; \
+	for p in $$list; do \
+	  if test -f $$p; then \
+	    $(am__strip_dir) \
+	    echo " ( cd '$(DESTDIR)$(libdir)' && $(RANLIB) $$f )"; \
+	    ( cd "$(DESTDIR)$(libdir)" && $(RANLIB) $$f ) || exit $$?; \
+	  else :; fi; \
+	done
+
+uninstall-libLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@list='$(lib_LIBRARIES)'; test -n "$(libdir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	test -n "$$files" || exit 0; \
+	echo " ( cd '$(DESTDIR)$(libdir)' && rm -f "$$files" )"; \
+	cd "$(DESTDIR)$(libdir)" && rm -f $$files
+
+clean-libLIBRARIES:
+	-test -z "$(lib_LIBRARIES)" || rm -f $(lib_LIBRARIES)
+libabsyntax.a: $(libabsyntax_a_OBJECTS) $(libabsyntax_a_DEPENDENCIES) 
+	-rm -f libabsyntax.a
+	$(libabsyntax_a_AR) libabsyntax.a $(libabsyntax_a_OBJECTS) $(libabsyntax_a_LIBADD)
+	$(RANLIB) libabsyntax.a
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/absyntax.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/visitor.Po@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@	$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@	$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	set x; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LIBRARIES)
+installdirs:
+	for dir in "$(DESTDIR)$(libdir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libLIBRARIES mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-libLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libLIBRARIES ctags distclean distclean-compile \
+	distclean-generic distclean-tags distdir dvi dvi-am html \
+	html-am info info-am install install-am install-data \
+	install-data-am install-dvi install-dvi-am install-exec \
+	install-exec-am install-html install-html-am install-info \
+	install-info-am install-libLIBRARIES install-man install-pdf \
+	install-pdf-am install-ps install-ps-am install-strip \
+	installcheck installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-compile \
+	mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
+	uninstall-am uninstall-libLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- a/absyntax/absyntax.cc	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax/absyntax.cc	Thu Sep 08 20:25:00 2011 +0200
@@ -41,10 +41,11 @@
 //#include "../stage1_2/iec.hh" /* required for BOGUS_TOKEN_ID, etc... */
 #include "visitor.hh"
 
-#define ABORT(str) {printf("ERROR: %s\n", str); exit(0);}
-
-
-
+#define ERROR error_exit(__FILE__,__LINE__)
+/* function defined in main.cc */
+extern void error_exit(const char *file_name, int line_no);
+
+#define ABORT(str) {printf("ERROR: %s\n", str); ERROR;}
 
 
 
@@ -94,7 +95,7 @@
   add_element(elem);
 }
 
-/* insert a new element */
+/* append a new element to the end of the list */
 void list_c::add_element(symbol_c *elem) {
 //printf("list_c::add_element()\n");
   n++;
@@ -125,10 +126,24 @@
   }
 }
 
-
-
-
-#define SYM_LIST(class_name_c)									\
+/* insert a new element before position pos. */
+/* To insert into the begining of list, call with pos=0  */
+/* To insert into the end of list, call with pos=list->n */
+void list_c::insert_element(symbol_c *elem, int pos) {
+  int i;
+  if (pos > n) ERROR;
+  
+  /* add new element to end of list. Basically alocate required memory... */
+  /* will also increment n by 1 ! */
+  add_element(elem);
+  /* if not inserting into end position, shift all elements up one position, to open up a slot in pos for new element */
+  if (pos < (n-1)) for (i = n-2; i >= pos; i--) elements[i+1] = elements[i];
+  elements[pos] = elem;
+}
+
+
+
+#define SYM_LIST(class_name_c, ...)								\
 class_name_c::class_name_c(									\
                            int fl, int fc, const char *ffile, long int forder,			\
                            int ll, int lc, const char *lfile, long int lorder)			\
@@ -139,14 +154,14 @@
 			:list_c(elem, fl, fc, ffile, forder, ll, lc, lfile, lorder) {}		\
 void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}
 
-#define SYM_TOKEN(class_name_c)									\
+#define SYM_TOKEN(class_name_c, ...)								\
 class_name_c::class_name_c(const char *value, 							\
                            int fl, int fc, const char *ffile, long int forder,			\
                            int ll, int lc, const char *lfile, long int lorder)			\
 			:token_c(value, fl, fc, ffile, forder, ll, lc, lfile, lorder) {}	\
 void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}
 
-#define SYM_REF0(class_name_c)									\
+#define SYM_REF0(class_name_c, ...)								\
 class_name_c::class_name_c(									\
                            int fl, int fc, const char *ffile, long int forder,			\
                            int ll, int lc, const char *lfile, long int lorder)			\
@@ -154,43 +169,43 @@
 void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}
 
 
-#define SYM_REF1(class_name_c, ref1)								\
-class_name_c::class_name_c(symbol_c *ref1,							\
-                           int fl, int fc, const char *ffile, long int forder,			\
-                           int ll, int lc, const char *lfile, long int lorder)			\
-			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\
-  this->ref1 = ref1;										\
-}												\
-void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}
-
-
-#define SYM_REF2(class_name_c, ref1, ref2)							\
-class_name_c::class_name_c(symbol_c *ref1,							\
-			   symbol_c *ref2,							\
-                           int fl, int fc, const char *ffile, long int forder,			\
-                           int ll, int lc, const char *lfile, long int lorder)			\
-			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\
-  this->ref1 = ref1;										\
-  this->ref2 = ref2;										\
-}												\
-void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}
-
-
-#define SYM_REF3(class_name_c, ref1, ref2, ref3)						\
-class_name_c::class_name_c(symbol_c *ref1,							\
-			   symbol_c *ref2,							\
-			   symbol_c *ref3,							\
-                           int fl, int fc, const char *ffile, long int forder,			\
-                           int ll, int lc, const char *lfile, long int lorder)			\
-			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\
-  this->ref1 = ref1;										\
-  this->ref2 = ref2;										\
-  this->ref3 = ref3;										\
-}												\
-void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}
-
-
-#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4)						\
+#define SYM_REF1(class_name_c, ref1, ...)							\
+class_name_c::class_name_c(symbol_c *ref1,							\
+                           int fl, int fc, const char *ffile, long int forder,			\
+                           int ll, int lc, const char *lfile, long int lorder)			\
+			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\
+  this->ref1 = ref1;										\
+}												\
+void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}
+
+
+#define SYM_REF2(class_name_c, ref1, ref2, ...)							\
+class_name_c::class_name_c(symbol_c *ref1,							\
+			   symbol_c *ref2,							\
+                           int fl, int fc, const char *ffile, long int forder,			\
+                           int ll, int lc, const char *lfile, long int lorder)			\
+			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\
+  this->ref1 = ref1;										\
+  this->ref2 = ref2;										\
+}												\
+void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}
+
+
+#define SYM_REF3(class_name_c, ref1, ref2, ref3, ...)						\
+class_name_c::class_name_c(symbol_c *ref1,							\
+			   symbol_c *ref2,							\
+			   symbol_c *ref3,							\
+                           int fl, int fc, const char *ffile, long int forder,			\
+                           int ll, int lc, const char *lfile, long int lorder)			\
+			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\
+  this->ref1 = ref1;										\
+  this->ref2 = ref2;										\
+  this->ref3 = ref3;										\
+}												\
+void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}
+
+
+#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4, ...)					\
 class_name_c::class_name_c(symbol_c *ref1,							\
 			   symbol_c *ref2,							\
 			   symbol_c *ref3,							\
@@ -206,7 +221,7 @@
 void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}
 
 
-#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5)					\
+#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5, ...)				\
 class_name_c::class_name_c(symbol_c *ref1,							\
 			   symbol_c *ref2,							\
 			   symbol_c *ref3,							\
@@ -225,7 +240,7 @@
 
 
 
-#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6)				\
+#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6, ...)				\
 class_name_c::class_name_c(symbol_c *ref1,							\
 			   symbol_c *ref2,							\
 			   symbol_c *ref3,							\
--- a/absyntax/absyntax.def	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax/absyntax.def	Thu Sep 08 20:25:00 2011 +0200
@@ -538,6 +538,33 @@
 /* | var1_list ',' variable_name */
 SYM_LIST(var1_list_c)
 
+/* | [var1_list ','] variable_name integer '..' */
+/* NOTE: This is an extension to the standard!!! */
+/* In order to be able to handle extensible standard functions
+ * (i.e. standard functions that may have a variable number of
+ * input parameters, such as AND(word#33, word#44, word#55, word#66),
+ * we have extended the acceptable syntax to allow var_name '..'
+ * in an input variable declaration.
+ *
+ * This allows us to parse the declaration of standard
+ * extensible functions and load their interface definition
+ * into the abstract syntax tree just like we do to other 
+ * user defined functions.
+ * This has the advantage that we can later do semantic
+ * checking of calls to functions (be it a standard or user defined
+ * function) in (almost) exactly the same way.
+ *
+ * The integer tells the compiler the number of the first parameter.
+ * for example, for ADD(IN1 := 11, IN2:=22), the index for IN starts off at 1.
+ * Some other standard library functions, such as MUX, has the extensible
+ * variable starting off from 0 (IN0, IN1, IN2, ...).
+ *
+ * Of course, we have a flag that disables this syntax when parsing user
+ * written code, so we only allow this extra syntax while parsing the 
+ * 'header' file that declares all the standard IEC 61131-3 functions.
+ */
+SYM_REF2(extensible_input_parameter_c, var_name, first_index)
+
 /* var1_list ':' array_spec_init */
 SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)
 
@@ -632,7 +659,15 @@
 /*  STRING ['[' integer ']'] [ASSIGN single_byte_character_string] */
 /* integer ->may be NULL ! */
 /* single_byte_character_string ->may be NULL ! */
-SYM_REF2(single_byte_string_spec_c, integer, single_byte_character_string)
+SYM_REF2(single_byte_string_spec_c, string_spec, single_byte_character_string)
+
+/*   STRING ['[' integer ']'] */
+/* integer ->may be NULL ! */
+SYM_REF2(single_byte_limited_len_string_spec_c, string_type_name, character_string_len)
+
+/*  WSTRING ['[' integer ']'] */
+/* integer ->may be NULL ! */
+SYM_REF2(double_byte_limited_len_string_spec_c, string_type_name, character_string_len)
 
 /*  var1_list ':' double_byte_string_spec */
 SYM_REF2(double_byte_string_var_declaration_c, var1_list, double_byte_string_spec)
@@ -640,7 +675,7 @@
 /*  WSTRING ['[' integer ']'] [ASSIGN double_byte_character_string] */
 /* integer ->may be NULL ! */
 /* double_byte_character_string ->may be NULL ! */
-SYM_REF2(double_byte_string_spec_c, integer, double_byte_character_string)
+SYM_REF2(double_byte_string_spec_c, string_spec, double_byte_character_string)
 
 /*| VAR [RETAIN|NON_RETAIN] incompl_located_var_decl_list END_VAR */
 /* option ->may be NULL ! */
@@ -885,7 +920,10 @@
 SYM_REF2(il_simple_operation_c, il_simple_operator, il_operand)
 
 /* | function_name [il_operand_list] */
-SYM_REF2(il_function_call_c, function_name, il_operand_list)
+/* NOTE: The parameter 'called_function_declaration' is used to pass data between the stage 3 and stage 4.
+ *       See the comment above function_invocation_c for more details 
+ */
+SYM_REF2(il_function_call_c, function_name, il_operand_list, symbol_c *called_function_declaration; int extensible_param_count;)
 
 
 /* | il_expr_operator '(' [il_operand] eol_list [simple_instr_list] ')' */
@@ -904,7 +942,10 @@
 
 
 /* | function_name '(' eol_list [il_param_list] ')' */
-SYM_REF2(il_formal_funct_call_c, function_name, il_param_list)
+/* NOTE: The parameter 'called_function_declaration' is used to pass data between the stage 3 and stage 4.
+ *       See the comment above function_invocation_c for more details 
+ */
+SYM_REF2(il_formal_funct_call_c, function_name, il_param_list, symbol_c *called_function_declaration; int extensible_param_count;)
 
 /* | il_operand_list ',' il_operand */
 SYM_LIST(il_operand_list_c)
@@ -1004,7 +1045,17 @@
 
 /*    formal_param_list -> may be NULL ! */
 /* nonformal_param_list -> may be NULL ! */
-SYM_REF3(function_invocation_c, function_name, formal_param_list, nonformal_param_list)
+/* NOTE: The parameter 'called_function_declaration' is used to pass data between the stage 3 and stage 4.
+ *       The IEC 61131-3 standard allows for overloaded standard functions. This means that some
+ *       function calls are not compeletely defined by the name of the function being called,
+ *       and need to be disambiguated with using the data types of the parameters being passed.
+ *       Stage 3 does this to verify semantic correctnes.
+ *       Stage 4 also needs to do this in order to determine which function to call.
+ *       It does not make sense to determine the exact function being called twice (once in stage 3,
+ *       and again in stage 4), so stage 3 will store this infor in the parameter called_function_declaration
+ *       for stage 4 to use it later on.
+ */
+SYM_REF3(function_invocation_c, function_name, formal_param_list, nonformal_param_list, symbol_c *called_function_declaration; int extensible_param_count;)
 
 
 /********************/
--- a/absyntax/absyntax.hh	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax/absyntax.hh	Thu Sep 08 20:25:00 2011 +0200
@@ -119,16 +119,22 @@
            int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0, /* order in which it is read by lexcial analyser */
            int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0  /* order in which it is read by lexcial analyser */
           );
-     /* insert a new element */
+     /* append a new element to the end of the list */
     virtual void add_element(symbol_c *elem);
-};
-
-
-
-
-#define SYM_LIST(class_name_c)												\
+     /* insert a new element before position pos. */
+     /* To insert into the begining of list, call with pos=0  */
+     /* To insert into the end of list, call with pos=list->n */
+    virtual void insert_element(symbol_c *elem, int pos = 0);
+};
+
+
+
+
+#define SYM_LIST(class_name_c, ...)												\
 class class_name_c:	public list_c {											\
   public:														\
+    __VA_ARGS__														\
+  public:														\
     class_name_c(													\
                  int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\
                  int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\
@@ -139,9 +145,11 @@
 };
 
 
-#define SYM_TOKEN(class_name_c)												\
+#define SYM_TOKEN(class_name_c, ...)												\
 class class_name_c: 	public token_c {										\
   public:														\
+    __VA_ARGS__														\
+  public:														\
     class_name_c(const char *value, 											\
                  int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\
                  int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\
@@ -149,8 +157,10 @@
 };
 
 
-#define SYM_REF0(class_name_c)												\
-class class_name_c: public symbol_c {											\
+#define SYM_REF0(class_name_c, ...)												\
+class class_name_c: public symbol_c {											\
+  public:														\
+    __VA_ARGS__														\
   public:														\
     class_name_c(		 											\
                  int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\
@@ -159,23 +169,25 @@
 };
 
 
-#define SYM_REF1(class_name_c, ref1)											\
-class class_name_c: public symbol_c {											\
-  public:														\
-    symbol_c *ref1;													\
-  public:														\
-    class_name_c(symbol_c *ref1,											\
-                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\
-                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\
-    virtual void *accept(visitor_c &visitor);										\
-};
-
-
-#define SYM_REF2(class_name_c, ref1, ref2)										\
-class class_name_c: public symbol_c {											\
-  public:														\
-    symbol_c *ref1;													\
-    symbol_c *ref2;													\
+#define SYM_REF1(class_name_c, ref1, ...)										\
+class class_name_c: public symbol_c {											\
+  public:														\
+    symbol_c *ref1;													\
+    __VA_ARGS__														\
+  public:														\
+    class_name_c(symbol_c *ref1,											\
+                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\
+                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\
+    virtual void *accept(visitor_c &visitor);										\
+};
+
+
+#define SYM_REF2(class_name_c, ref1, ref2, ...)										\
+class class_name_c: public symbol_c {											\
+  public:														\
+    symbol_c *ref1;													\
+    symbol_c *ref2;													\
+    __VA_ARGS__														\
   public:														\
     class_name_c(symbol_c *ref1,											\
 		 symbol_c *ref2 = NULL,											\
@@ -185,29 +197,31 @@
 };
 
 
-#define SYM_REF3(class_name_c, ref1, ref2, ref3)									\
-class class_name_c: public symbol_c {											\
-  public:														\
-    symbol_c *ref1;													\
-    symbol_c *ref2;													\
-    symbol_c *ref3;													\
-  public:														\
-    class_name_c(symbol_c *ref1,											\
-		 symbol_c *ref2,											\
-		 symbol_c *ref3,											\
-                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\
-                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\
-    virtual void *accept(visitor_c &visitor);										\
-};
-
-
-#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4)									\
+#define SYM_REF3(class_name_c, ref1, ref2, ref3, ...)									\
+class class_name_c: public symbol_c {											\
+  public:														\
+    symbol_c *ref1;													\
+    symbol_c *ref2;													\
+    symbol_c *ref3;													\
+    __VA_ARGS__														\
+  public:														\
+    class_name_c(symbol_c *ref1,											\
+		 symbol_c *ref2,											\
+		 symbol_c *ref3,											\
+                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\
+                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\
+    virtual void *accept(visitor_c &visitor);										\
+};
+
+
+#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4, ...)								\
 class class_name_c: public symbol_c {											\
   public:														\
     symbol_c *ref1;													\
     symbol_c *ref2;													\
     symbol_c *ref3;													\
     symbol_c *ref4;													\
+    __VA_ARGS__														\
   public:														\
     class_name_c(symbol_c *ref1,											\
 		 symbol_c *ref2,											\
@@ -219,7 +233,7 @@
 };
 
 
-#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5)								\
+#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5, ...)								\
 class class_name_c: public symbol_c {											\
   public:														\
     symbol_c *ref1;													\
@@ -227,6 +241,7 @@
     symbol_c *ref3;													\
     symbol_c *ref4;													\
     symbol_c *ref5;													\
+    __VA_ARGS__														\
   public:														\
     class_name_c(symbol_c *ref1,											\
 		 symbol_c *ref2,											\
@@ -239,7 +254,7 @@
 };
 
 
-#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6)							\
+#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6, ...)							\
 class class_name_c: public symbol_c {											\
   public:														\
     symbol_c *ref1;													\
@@ -248,6 +263,7 @@
     symbol_c *ref4;													\
     symbol_c *ref5;													\
     symbol_c *ref6;													\
+    __VA_ARGS__														\
   public:														\
     class_name_c(symbol_c *ref1,											\
 		 symbol_c *ref2,											\
--- a/absyntax/visitor.cc	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax/visitor.cc	Thu Sep 08 20:25:00 2011 +0200
@@ -82,19 +82,19 @@
 #define SYM_REF1(class_name_c, ref1)	\
   void *null_visitor_c::visit(class_name_c *symbol) {return NULL;}
 
-#define SYM_REF2(class_name_c, ref1, ref2)	\
-  void *null_visitor_c::visit(class_name_c *symbol) {return NULL;}
-
-#define SYM_REF3(class_name_c, ref1, ref2, ref3)	\
-  void *null_visitor_c::visit(class_name_c *symbol) {return NULL;}
-
-#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4)	\
-  void *null_visitor_c::visit(class_name_c *symbol) {return NULL;}
-
-#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5)	\
-  void *null_visitor_c::visit(class_name_c *symbol) {return NULL;}
-
-#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6)	\
+#define SYM_REF2(class_name_c, ref1, ref2, ...)	\
+  void *null_visitor_c::visit(class_name_c *symbol) {return NULL;}
+
+#define SYM_REF3(class_name_c, ref1, ref2, ref3, ...)	\
+  void *null_visitor_c::visit(class_name_c *symbol) {return NULL;}
+
+#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4, ...)	\
+  void *null_visitor_c::visit(class_name_c *symbol) {return NULL;}
+
+#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5, ...)	\
+  void *null_visitor_c::visit(class_name_c *symbol) {return NULL;}
+
+#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6, ...)	\
   void *null_visitor_c::visit(class_name_c *symbol) {return NULL;}
 
 
@@ -148,31 +148,31 @@
   return NULL;						\
 }
 
-#define SYM_REF2(class_name_c, ref1, ref2)		\
+#define SYM_REF2(class_name_c, ref1, ref2, ...)		\
 void *iterator_visitor_c::visit(class_name_c *symbol) {	\
   if (symbol->ref1!=NULL) symbol->ref1->accept(*this);	\
   if (symbol->ref2!=NULL) symbol->ref2->accept(*this);	\
   return NULL;						\
 }
 
-#define SYM_REF3(class_name_c, ref1, ref2, ref3)	\
-void *iterator_visitor_c::visit(class_name_c *symbol) {	\
-  if (symbol->ref1) symbol->ref1->accept(*this);	\
-  if (symbol->ref2) symbol->ref2->accept(*this);	\
-  if (symbol->ref3) symbol->ref3->accept(*this);	\
-  return NULL;						\
-}
-
-#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4)	\
-void *iterator_visitor_c::visit(class_name_c *symbol) {	\
-  if (symbol->ref1) symbol->ref1->accept(*this);	\
-  if (symbol->ref2) symbol->ref2->accept(*this);	\
-  if (symbol->ref3) symbol->ref3->accept(*this);	\
-  if (symbol->ref4) symbol->ref4->accept(*this);	\
-  return NULL;						\
-}
-
-#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5)		\
+#define SYM_REF3(class_name_c, ref1, ref2, ref3, ...)			\
+void *iterator_visitor_c::visit(class_name_c *symbol) {			\
+  if (symbol->ref1) symbol->ref1->accept(*this);			\
+  if (symbol->ref2) symbol->ref2->accept(*this);			\
+  if (symbol->ref3) symbol->ref3->accept(*this);			\
+  return NULL;								\
+}
+
+#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4, ...)		\
+void *iterator_visitor_c::visit(class_name_c *symbol) {			\
+  if (symbol->ref1) symbol->ref1->accept(*this);			\
+  if (symbol->ref2) symbol->ref2->accept(*this);			\
+  if (symbol->ref3) symbol->ref3->accept(*this);			\
+  if (symbol->ref4) symbol->ref4->accept(*this);			\
+  return NULL;								\
+}
+
+#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5, ...)	\
 void *iterator_visitor_c::visit(class_name_c *symbol) {			\
   if (symbol->ref1) symbol->ref1->accept(*this);			\
   if (symbol->ref2) symbol->ref2->accept(*this);			\
@@ -182,7 +182,7 @@
   return NULL;								\
 }
 
-#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6)	\
+#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6, ...)	\
 void *iterator_visitor_c::visit(class_name_c *symbol) {			\
   if (symbol->ref1) symbol->ref1->accept(*this);			\
   if (symbol->ref2) symbol->ref2->accept(*this);			\
@@ -250,7 +250,7 @@
   return NULL;							\
 }
 
-#define SYM_REF2(class_name_c, ref1, ref2)			\
+#define SYM_REF2(class_name_c, ref1, ref2, ...)			\
 void *search_visitor_c::visit(class_name_c *symbol) {		\
   void *res = NULL;						\
   if (symbol->ref1) res =  symbol->ref1->accept(*this);		\
@@ -259,7 +259,7 @@
   return NULL;							\
 }
 
-#define SYM_REF3(class_name_c, ref1, ref2, ref3)		\
+#define SYM_REF3(class_name_c, ref1, ref2, ref3, ...)		\
 void *search_visitor_c::visit(class_name_c *symbol) {		\
   void *res = NULL;						\
   if (symbol->ref1) res =  symbol->ref1->accept(*this);		\
@@ -270,7 +270,7 @@
   return NULL;							\
 }
 
-#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4)		\
+#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4, ...)		\
 void *search_visitor_c::visit(class_name_c *symbol) {		\
   void *res = NULL;						\
   if (symbol->ref1) res =  symbol->ref1->accept(*this);		\
@@ -283,7 +283,7 @@
   return NULL;							\
 }
 
-#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5)		\
+#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5, ...)		\
 void *search_visitor_c::visit(class_name_c *symbol) {			\
   void *res = NULL;							\
   if (symbol->ref1) res =  symbol->ref1->accept(*this);			\
@@ -298,7 +298,7 @@
   return NULL;								\
 }
 
-#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6)	\
+#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6, ...)	\
 void *search_visitor_c::visit(class_name_c *symbol) {			\
   void *res = NULL;							\
   if (symbol->ref1) res =  symbol->ref1->accept(*this);			\
--- a/absyntax/visitor.hh	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax/visitor.hh	Thu Sep 08 20:25:00 2011 +0200
@@ -78,31 +78,31 @@
 
 
 
-#define SYM_LIST(class_name_c)	\
-  virtual void *visit(class_name_c *symbol) = 0;
-
-#define SYM_TOKEN(class_name_c)	\
-  virtual void *visit(class_name_c *symbol) = 0;
-
-#define SYM_REF0(class_name_c)	\
-  virtual void *visit(class_name_c *symbol) = 0;
-
-#define SYM_REF1(class_name_c, ref1)		\
-  virtual void *visit(class_name_c *symbol) = 0;
-
-#define SYM_REF2(class_name_c, ref1, ref2)	\
-  virtual void *visit(class_name_c *symbol) = 0;
-
-#define SYM_REF3(class_name_c, ref1, ref2, ref3)	\
-  virtual void *visit(class_name_c *symbol) = 0;
-
-#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4)	\
-  virtual void *visit(class_name_c *symbol) = 0;
-
-#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5)		\
-  virtual void *visit(class_name_c *symbol) = 0;
-
-#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6)	\
+#define SYM_LIST(class_name_c, ...)	\
+  virtual void *visit(class_name_c *symbol) = 0;
+
+#define SYM_TOKEN(class_name_c, ...)	\
+  virtual void *visit(class_name_c *symbol) = 0;
+
+#define SYM_REF0(class_name_c, ...)	\
+  virtual void *visit(class_name_c *symbol) = 0;
+
+#define SYM_REF1(class_name_c, ref1, ...)		\
+  virtual void *visit(class_name_c *symbol) = 0;
+
+#define SYM_REF2(class_name_c, ref1, ref2, ...)	\
+  virtual void *visit(class_name_c *symbol) = 0;
+
+#define SYM_REF3(class_name_c, ref1, ref2, ref3, ...)	\
+  virtual void *visit(class_name_c *symbol) = 0;
+
+#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4, ...)	\
+  virtual void *visit(class_name_c *symbol) = 0;
+
+#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5, ...)		\
+  virtual void *visit(class_name_c *symbol) = 0;
+
+#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6, ...)	\
   virtual void *visit(class_name_c *symbol) = 0;
 
 class visitor_c {
@@ -127,31 +127,31 @@
 
 
 
-#define SYM_LIST(class_name_c)	\
-  virtual void *visit(class_name_c *symbol);
-
-#define SYM_TOKEN(class_name_c)	\
-  virtual void *visit(class_name_c *symbol);
-
-#define SYM_REF0(class_name_c)	\
-  virtual void *visit(class_name_c *symbol);
-
-#define SYM_REF1(class_name_c, ref1)		\
-  virtual void *visit(class_name_c *symbol);
-
-#define SYM_REF2(class_name_c, ref1, ref2)	\
-  virtual void *visit(class_name_c *symbol);
-
-#define SYM_REF3(class_name_c, ref1, ref2, ref3)	\
-  virtual void *visit(class_name_c *symbol);
-
-#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4)	\
-  virtual void *visit(class_name_c *symbol);
-
-#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5)		\
-  virtual void *visit(class_name_c *symbol);
-
-#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6)	\
+#define SYM_LIST(class_name_c, ...)	\
+  virtual void *visit(class_name_c *symbol);
+
+#define SYM_TOKEN(class_name_c, ...)	\
+  virtual void *visit(class_name_c *symbol);
+
+#define SYM_REF0(class_name_c, ...)	\
+  virtual void *visit(class_name_c *symbol);
+
+#define SYM_REF1(class_name_c, ref1, ...)		\
+  virtual void *visit(class_name_c *symbol);
+
+#define SYM_REF2(class_name_c, ref1, ref2, ...)	\
+  virtual void *visit(class_name_c *symbol);
+
+#define SYM_REF3(class_name_c, ref1, ref2, ref3, ...)	\
+  virtual void *visit(class_name_c *symbol);
+
+#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4, ...)	\
+  virtual void *visit(class_name_c *symbol);
+
+#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5, ...)		\
+  virtual void *visit(class_name_c *symbol);
+
+#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6, ...)	\
   virtual void *visit(class_name_c *symbol);
 
 
--- a/absyntax_utils/Makefile	Wed Sep 07 19:28:10 2011 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,55 +0,0 @@
-# matiec - a compiler for the programming languages defined in IEC 61131-3
-#
-# Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)
-# Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-# include the system specific Makefile
-include ../Makefile.$(shell uname)
-
-SEARCH_UTIL_FILES  = absyntax_utils.o
-SEARCH_UTIL_FILES += search_expression_type.o
-SEARCH_UTIL_FILES += decompose_var_instance_name.o
-SEARCH_UTIL_FILES += case_element_iterator.o
-SEARCH_UTIL_FILES += function_call_iterator.o
-SEARCH_UTIL_FILES += function_call_param_iterator.o
-SEARCH_UTIL_FILES += function_param_iterator.o
-SEARCH_UTIL_FILES += search_base_type.o
-SEARCH_UTIL_FILES += search_constant_type.o
-SEARCH_UTIL_FILES += search_fb_instance_decl.o
-SEARCH_UTIL_FILES += search_fb_typedecl.o
-SEARCH_UTIL_FILES += search_il_operand_type.o
-SEARCH_UTIL_FILES += search_varfb_instance_type.o
-SEARCH_UTIL_FILES += search_var_instance_decl.o
-SEARCH_UTIL_FILES += spec_init_separator.o
-SEARCH_UTIL_FILES += type_initial_value.o
-SEARCH_UTIL_FILES += add_en_eno_param_decl.o
-SEARCH_UTIL_FILES += get_sizeof_datatype.o
-SEARCH_UTIL_FILES += get_function_type.o
-
-default: all
-
-all: $(SEARCH_UTIL_FILES)
-
-clean:
-	rm -f *.o Makefile.depend
-
-CXXFLAGS += -I. -I../*
-
-Makefile.depend depend:
-	$(CXX) -MM -MG -I. *.cc \
-	  | sed 's/:/ Makefile.depend:/' > Makefile.depend
-
-include Makefile.depend
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/absyntax_utils/Makefile.am	Thu Sep 08 20:25:00 2011 +0200
@@ -0,0 +1,31 @@
+include ../common.mk
+
+lib_LIBRARIES = libabsyntax_utils.a
+
+libabsyntax_utils_a_SOURCES = \
+	absyntax_utils.cc \
+	add_en_eno_param_decl.cc \
+	decompose_var_instance_name.cc \
+	case_element_iterator.cc \
+	function_call_iterator.cc \
+	function_call_param_iterator.cc \
+	function_param_iterator.cc \
+	get_function_type.cc \
+	get_sizeof_datatype.cc \
+	search_base_type.cc \
+	search_constant_type.cc \
+	search_expression_type.cc \
+	search_fb_instance_decl.cc \
+	search_fb_typedecl.cc \
+	search_varfb_instance_type.cc \
+	search_var_instance_decl.cc \
+	spec_init_separator.cc \
+	type_initial_value.cc \
+	search_varfb_instance_type.cc \
+	search_var_instance_decl.cc \
+	spec_init_separator.cc \
+	type_initial_value.cc 
+
+#search_il_operand_type.cc 
+#search_type_code.c
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/absyntax_utils/Makefile.in	Thu Sep 08 20:25:00 2011 +0200
@@ -0,0 +1,542 @@
+# Makefile.in generated by automake 1.11.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation,
+# Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+DIST_COMMON = $(srcdir)/../common.mk $(srcdir)/Makefile.am \
+	$(srcdir)/Makefile.in
+subdir = absyntax_utils
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__installdirs = "$(DESTDIR)$(libdir)"
+LIBRARIES = $(lib_LIBRARIES)
+AR = ar
+ARFLAGS = cru
+libabsyntax_utils_a_AR = $(AR) $(ARFLAGS)
+libabsyntax_utils_a_LIBADD =
+am_libabsyntax_utils_a_OBJECTS = absyntax_utils.$(OBJEXT) \
+	add_en_eno_param_decl.$(OBJEXT) \
+	decompose_var_instance_name.$(OBJEXT) \
+	case_element_iterator.$(OBJEXT) \
+	function_call_iterator.$(OBJEXT) \
+	function_call_param_iterator.$(OBJEXT) \
+	function_param_iterator.$(OBJEXT) get_function_type.$(OBJEXT) \
+	get_sizeof_datatype.$(OBJEXT) search_base_type.$(OBJEXT) \
+	search_constant_type.$(OBJEXT) \
+	search_expression_type.$(OBJEXT) \
+	search_fb_instance_decl.$(OBJEXT) search_fb_typedecl.$(OBJEXT) \
+	search_varfb_instance_type.$(OBJEXT) \
+	search_var_instance_decl.$(OBJEXT) \
+	spec_init_separator.$(OBJEXT) type_initial_value.$(OBJEXT) \
+	search_varfb_instance_type.$(OBJEXT) \
+	search_var_instance_decl.$(OBJEXT) \
+	spec_init_separator.$(OBJEXT) type_initial_value.$(OBJEXT)
+libabsyntax_utils_a_OBJECTS = $(am_libabsyntax_utils_a_OBJECTS)
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)/config
+depcomp = $(SHELL) $(top_srcdir)/config/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+CXXLD = $(CXX)
+CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
+	-o $@
+SOURCES = $(libabsyntax_utils_a_SOURCES)
+DIST_SOURCES = $(libabsyntax_utils_a_SOURCES)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LEX = @LEX@
+LEXLIB = @LEXLIB@
+LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MKDIR_P = @MKDIR_P@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+RANLIB = @RANLIB@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+VERSION = @VERSION@
+YACC = @YACC@
+YFLAGS = @YFLAGS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build_alias = @build_alias@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host_alias = @host_alias@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+AM_CXXFLAGS = -g -Wall -Wpointer-arith -Wwrite-strings -Wno-unused 
+lib_LIBRARIES = libabsyntax_utils.a
+libabsyntax_utils_a_SOURCES = \
+	absyntax_utils.cc \
+	add_en_eno_param_decl.cc \
+	decompose_var_instance_name.cc \
+	case_element_iterator.cc \
+	function_call_iterator.cc \
+	function_call_param_iterator.cc \
+	function_param_iterator.cc \
+	get_function_type.cc \
+	get_sizeof_datatype.cc \
+	search_base_type.cc \
+	search_constant_type.cc \
+	search_expression_type.cc \
+	search_fb_instance_decl.cc \
+	search_fb_typedecl.cc \
+	search_varfb_instance_type.cc \
+	search_var_instance_decl.cc \
+	spec_init_separator.cc \
+	type_initial_value.cc \
+	search_varfb_instance_type.cc \
+	search_var_instance_decl.cc \
+	spec_init_separator.cc \
+	type_initial_value.cc 
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .o .obj
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(srcdir)/../common.mk $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign absyntax_utils/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign absyntax_utils/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+install-libLIBRARIES: $(lib_LIBRARIES)
+	@$(NORMAL_INSTALL)
+	test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)"
+	@list='$(lib_LIBRARIES)'; test -n "$(libdir)" || list=; \
+	list2=; for p in $$list; do \
+	  if test -f $$p; then \
+	    list2="$$list2 $$p"; \
+	  else :; fi; \
+	done; \
+	test -z "$$list2" || { \
+	  echo " $(INSTALL_DATA) $$list2 '$(DESTDIR)$(libdir)'"; \
+	  $(INSTALL_DATA) $$list2 "$(DESTDIR)$(libdir)" || exit $$?; }
+	@$(POST_INSTALL)
+	@list='$(lib_LIBRARIES)'; test -n "$(libdir)" || list=; \
+	for p in $$list; do \
+	  if test -f $$p; then \
+	    $(am__strip_dir) \
+	    echo " ( cd '$(DESTDIR)$(libdir)' && $(RANLIB) $$f )"; \
+	    ( cd "$(DESTDIR)$(libdir)" && $(RANLIB) $$f ) || exit $$?; \
+	  else :; fi; \
+	done
+
+uninstall-libLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@list='$(lib_LIBRARIES)'; test -n "$(libdir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	test -n "$$files" || exit 0; \
+	echo " ( cd '$(DESTDIR)$(libdir)' && rm -f "$$files" )"; \
+	cd "$(DESTDIR)$(libdir)" && rm -f $$files
+
+clean-libLIBRARIES:
+	-test -z "$(lib_LIBRARIES)" || rm -f $(lib_LIBRARIES)
+libabsyntax_utils.a: $(libabsyntax_utils_a_OBJECTS) $(libabsyntax_utils_a_DEPENDENCIES) 
+	-rm -f libabsyntax_utils.a
+	$(libabsyntax_utils_a_AR) libabsyntax_utils.a $(libabsyntax_utils_a_OBJECTS) $(libabsyntax_utils_a_LIBADD)
+	$(RANLIB) libabsyntax_utils.a
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/absyntax_utils.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/add_en_eno_param_decl.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/case_element_iterator.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/decompose_var_instance_name.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/function_call_iterator.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/function_call_param_iterator.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/function_param_iterator.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/get_function_type.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/get_sizeof_datatype.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/search_base_type.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/search_constant_type.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/search_expression_type.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/search_fb_instance_decl.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/search_fb_typedecl.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/search_var_instance_decl.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/search_varfb_instance_type.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/spec_init_separator.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/type_initial_value.Po@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@	$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@	$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	set x; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LIBRARIES)
+installdirs:
+	for dir in "$(DESTDIR)$(libdir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libLIBRARIES mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-libLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libLIBRARIES ctags distclean distclean-compile \
+	distclean-generic distclean-tags distdir dvi dvi-am html \
+	html-am info info-am install install-am install-data \
+	install-data-am install-dvi install-dvi-am install-exec \
+	install-exec-am install-html install-html-am install-info \
+	install-info-am install-libLIBRARIES install-man install-pdf \
+	install-pdf-am install-ps install-ps-am install-strip \
+	installcheck installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-compile \
+	mostlyclean-generic pdf pdf-am ps ps-am tags uninstall \
+	uninstall-am uninstall-libLIBRARIES
+
+
+#search_il_operand_type.cc 
+#search_type_code.c
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
--- a/absyntax_utils/absyntax_utils.cc	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax_utils/absyntax_utils.cc	Thu Sep 08 20:25:00 2011 +0200
@@ -50,6 +50,8 @@
 #include <typeinfo>
 #include <list>
 #include <strings.h>
+#include <string.h>  /* required for strlen() */
+#include <stdlib.h>  /* required for atoi() */
 
 #include "../util/symtable.hh"
 #include "../util/dsymtable.hh"
@@ -94,6 +96,25 @@
 }
 
 
+/* extract the value of an integer from an integer_c object !! */
+/* NOTE: it must ignore underscores! */
+int extract_integer(symbol_c *sym) {
+  std::string str = "";
+  integer_c *integer;
+  neg_integer_c * neg_integer;
+
+  if ((neg_integer = dynamic_cast<neg_integer_c *>(sym)) != NULL)
+    return - extract_integer((integer_c *)neg_integer->exp);
+  
+  if ((integer = dynamic_cast<integer_c *>(sym)) == NULL) ERROR;
+
+  for(unsigned int i = 0; i < strlen(integer->value); i++)
+    if (integer->value[i] != '_')  str += integer->value[i];
+
+  return atoi(str.c_str());
+}
+
+
 
 /***********************************************************************/
 /***********************************************************************/
--- a/absyntax_utils/absyntax_utils.hh	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax_utils/absyntax_utils.hh	Thu Sep 08 20:25:00 2011 +0200
@@ -55,9 +55,13 @@
 /* returns 0 if the names are equal!! Case is ignored. */
 int compare_identifiers(symbol_c *ident1, symbol_c *ident2);
 
+/* extract the value of an integer from an integer_c object !! */
+int extract_integer(symbol_c *integer);
+  
 /* A symbol table with all globally declared functions... */
 extern function_declaration_c null_symbol1;
-extern dsymtable_c<function_declaration_c *, &null_symbol1> function_symtable;
+typedef dsymtable_c<function_declaration_c *, &null_symbol1> function_symtable_t;
+extern function_symtable_t function_symtable;
 
 /* A symbol table with all globally declared functions block types... */
 extern function_block_declaration_c null_symbol2;
--- a/absyntax_utils/add_en_eno_param_decl.cc	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax_utils/add_en_eno_param_decl.cc	Thu Sep 08 20:25:00 2011 +0200
@@ -150,8 +150,17 @@
     en_declared  = false; 
     eno_declared = false; 
     iterate_list(symbol);
+    /* insert elements to begining of list! */
+    /* We want EN first, and then ENO.
+     * But, since we are insertin them into the head of the list, we must insert EN last so it will stay in the first position!
+     */
+    if(eno_declared == false) symbol->insert_element(build_eno_param());
+    if(en_declared  == false) symbol->insert_element(build_en_param());
+    /* append elements to end of list! */
+    /*
     if(en_declared  == false) symbol->add_element(build_en_param());
     if(eno_declared == false) symbol->add_element(build_eno_param());
+    */
     return NULL;
 }
 
--- a/absyntax_utils/function_call_param_iterator.cc	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax_utils/function_call_param_iterator.cc	Thu Sep 08 20:25:00 2011 +0200
@@ -221,6 +221,13 @@
   return (symbol_c *)res;
 }
 
+/* Search for the value passed to the parameter named <param_name>...  */
+symbol_c *function_call_param_iterator_c::search_f(const char *param_name) {
+  identifier_c tmp_indentifier(param_name);
+  return search_f(&tmp_indentifier);
+}
+
+
 /* Returns the value being passed to the current parameter. */
 symbol_c *function_call_param_iterator_c::get_current_value(void) {
   return current_value;
--- a/absyntax_utils/function_call_param_iterator.hh	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax_utils/function_call_param_iterator.hh	Thu Sep 08 20:25:00 2011 +0200
@@ -104,6 +104,7 @@
 
     /* Search for the value passed to the parameter named <param_name>...  */
     symbol_c *search_f(symbol_c *param_name);
+    symbol_c *search_f(const char *param_name);
 
     /* Returns the value being passed to the current parameter. */
     symbol_c *get_current_value(void);
--- a/absyntax_utils/function_param_iterator.cc	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax_utils/function_param_iterator.cc	Thu Sep 08 20:25:00 2011 +0200
@@ -48,8 +48,11 @@
 
 
 
-#include "function_param_iterator.hh"
-#include "spec_init_separator.hh"
+#include "absyntax_utils.hh"  /* required for extract_integer() */
+// #include "function_param_iterator.hh"  /* no longer required, aready included by absyntax_utils.hh */
+// #include "spec_init_separator.hh"  /* no longer required, aready included by absyntax_utils.hh */
+#include <stdlib.h>  /* required for strtol() */
+#include <string.h>
 #include <strings.h>
 
 
@@ -67,6 +70,49 @@
 
 
 
+/* compare the name of two __extensible__ function parameters.
+ * The usual use case is to have one of the parameters as used
+ * in the function declaration, and another as used in a formal function call.
+ *
+ * Will return:
+ *         < 0 : if two parameters are not compatible, or one is invalid
+ *        >= 0 : if both parameters ..........
+ */
+/*
+ *   ("in", "i0")      -> returns error (<0)
+ *   ("in1", "in")     -> returns error (<0)
+ *   ("in", "in")      -> returns error (<0)
+ *   ("in", "inw")     -> returns error (<0)
+ *   ("in", "in10.4")  -> returns error (<0)
+ *   ("in", "in10e")   -> returns error (<0)
+ *   ("in", "")        -> returns error (<0)
+ *   ("", "in10e")     -> returns error (<0)
+ *   ("in", "in0")     -> returns 0
+ *   ("in", "in9")     -> returns 9
+ *   ("in", "in42")    -> returns 42
+ *   ("in", "in-42")   -> returns -42 (error!)
+ */
+int function_param_iterator_c::cmp_extparam_names(const char* s1, const char* s2) {
+  int res;
+  char *endptr;
+  int len;
+
+  if ((s1 == NULL) || (s2 == NULL) || (*s1 == '\0') || (*s2 == '\0')) return -1;
+
+  len = strlen(s1);
+  if (strncasecmp(s1, s2, len)) return -2;
+
+  s1 = &s2[len];
+  if (*s1 == '\0') return -3;
+
+  res = strtol(s1, &endptr, 10);
+  if (*endptr != '\0') return -4;
+
+  return res;
+}
+
+
+
 void* function_param_iterator_c::handle_param_list(list_c *list) {
   switch (current_operation) {
     case iterate_op:
@@ -79,12 +125,27 @@
 
     case search_op:
       for(int i = 0; i < list->n; i++) {
-        identifier_c *variable_name = dynamic_cast<identifier_c *>(list->elements[i]);
+        symbol_c *sym = list->elements[i];
+        extensible_input_parameter_c *extensible_parameter = dynamic_cast<extensible_input_parameter_c *>(sym);
+        if (extensible_parameter != NULL) {
+          sym = extensible_parameter->var_name;
+          current_param_is_extensible = true;
+          _first_extensible_param_index = extract_integer(extensible_parameter->first_index);
+        }
+        identifier_c *variable_name = dynamic_cast<identifier_c *>(sym);
         if (variable_name == NULL) ERROR;
-
-        if (strcasecmp(search_param_name->value, variable_name->value) == 0)
-          /* FOUND! This is the same parameter!! */
-          return (void *)variable_name;
+        
+        if (!current_param_is_extensible)
+          if (strcasecmp(search_param_name->value, variable_name->value) == 0)
+            /* FOUND! This is the same parameter!! */
+            return (void *)variable_name;
+  
+        if (current_param_is_extensible) {
+          current_extensible_param_index = cmp_extparam_names(variable_name->value, search_param_name->value);
+          if (current_extensible_param_index >= 0)
+            /* FOUND! This is a compatible extensible parameter!! */
+            return (void *)variable_name;
+        }  
       }
       break;
   } /* switch */
@@ -102,12 +163,26 @@
       break;
 
     case search_op:
+      extensible_input_parameter_c *extensible_parameter = dynamic_cast<extensible_input_parameter_c *>(var_name);
+      if (extensible_parameter != NULL) {
+        var_name = extensible_parameter->var_name;
+        current_param_is_extensible = true;
+        _first_extensible_param_index = extract_integer(extensible_parameter->first_index);
+      }
       identifier_c *variable_name = dynamic_cast<identifier_c *>(var_name);
       if (variable_name == NULL) ERROR;
-
-      if (strcasecmp(search_param_name->value, variable_name->value) == 0)
-        /* FOUND! This is the same parameter!! */
-        return (void *)variable_name;
+      
+      if (!current_param_is_extensible)
+        if (strcasecmp(search_param_name->value, variable_name->value) == 0)
+          /* FOUND! This is the same parameter!! */
+          return (void *)variable_name;
+
+      if (current_param_is_extensible) {
+        current_extensible_param_index = cmp_extparam_names(variable_name->value, search_param_name->value);
+        if (current_extensible_param_index >= 0)
+          /* FOUND! This is a compatible extensible parameter!! */
+          return (void *)variable_name;
+      }  
       break;
   } /* switch */
 
@@ -128,6 +203,8 @@
 /* start off at the first parameter once again... */
 void function_param_iterator_c::reset(void) {
   next_param = param_count = 0;
+  _first_extensible_param_index = -1;
+  current_param_is_extensible = false;
   current_param_name = NULL;
   current_param_type = current_param_default_value = NULL;
 }
@@ -166,6 +243,11 @@
   void *res;
   identifier_c *identifier;
  
+  if (current_param_is_extensible) {
+    current_extensible_param_index++;
+    return current_param_name;
+  }
+  
   param_count = 0;
   en_eno_param_implicit = false;
   next_param++;
@@ -175,6 +257,13 @@
     return NULL;
 
   symbol_c *sym = (symbol_c *)res;
+  extensible_input_parameter_c *extensible_parameter = dynamic_cast<extensible_input_parameter_c *>(sym);
+  if (extensible_parameter != NULL) {
+    sym = extensible_parameter->var_name;
+    current_param_is_extensible = true;
+    _first_extensible_param_index = extract_integer(extensible_parameter->first_index);
+    current_extensible_param_index = _first_extensible_param_index;
+  }
   identifier = dynamic_cast<identifier_c *>(sym);
   if (identifier == NULL)
     ERROR;
@@ -187,6 +276,8 @@
   if (NULL == param_name) ERROR;
   search_param_name = dynamic_cast<identifier_c *>(param_name);
   if (NULL == search_param_name) ERROR;
+  en_eno_param_implicit = false;
+  current_param_is_extensible = false;
   current_operation = function_param_iterator_c::search_op;
   void *res = f_decl->accept(*this);
   identifier_c *res_param_name = dynamic_cast<identifier_c *>((symbol_c *)res);
@@ -210,6 +301,24 @@
   return en_eno_param_implicit;
 }
 
+/* Returns if currently referenced parameter is an extensible parameter. */
+/* extensible paramters only occur in some standard functions, e.g. AND(word#34, word#44, word#65); */
+bool function_param_iterator_c::is_extensible_param(void) {
+  return current_param_is_extensible;
+}
+
+/* Returns the index of the current extensible parameter. */             
+/* If the current parameter is not an extensible paramter, returns -1 */
+int function_param_iterator_c::extensible_param_index(void) {
+  return (current_param_is_extensible? current_extensible_param_index : -1);
+}
+
+/* Returns the index of the first extensible parameter, or -1 if no extensible parameter found. */             
+/* WARNING: Will only return the correct value _after_ an extensible parameter has been found! */
+int function_param_iterator_c::first_extensible_param_index(void) {
+  return _first_extensible_param_index;
+}
+
 /* Returns the currently referenced parameter's data passing direction.
  * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT
  */
@@ -218,7 +327,7 @@
 }
 
 void *function_param_iterator_c::visit(implicit_definition_c *symbol) {
-	en_eno_param_implicit = current_operation == function_param_iterator_c::iterate_op;
+	en_eno_param_implicit = true;
 	return NULL;
 }
 
@@ -243,12 +352,15 @@
    * variables will get overwritten when we visit the next
    * var1_init_decl_c list!
    */
-  symbol->method->accept(*this);
-
   current_param_default_value = symbol->value;
   current_param_type = symbol->type;
 
-  return handle_single_param(symbol->name);
+  void *res = handle_single_param(symbol->name);
+  
+    /* If we have found the parameter we will be returning, we set the en_eno_param_implicit to TRUE if implicitly defined */
+  if (res != NULL) symbol->method->accept(*this);
+  
+  return res;
 }
 
 /* var1_list ':' array_spec_init */
@@ -278,6 +390,7 @@
   current_param_direction = direction_out;
   return symbol->var_init_decl_list->accept(*this);
 }
+
 void *function_param_iterator_c::visit(eno_param_declaration_c *symbol) {
   TRACE("eno_param_declaration_c");
   /* It is OK to store these values in the current_param_XXX
@@ -286,18 +399,23 @@
    * variables will get overwritten when we visit the next
    * var1_init_decl_c list!
    */
-  symbol->method->accept(*this);
-
   current_param_default_value = NULL;
   current_param_type = symbol->type;
 
-  return handle_single_param(symbol->name);
-}
+  void *res = handle_single_param(symbol->name);
+  
+    /* If we have found the parameter we will be returning, we set the en_eno_param_implicit to TRUE if implicitly defined */
+  if (res != NULL) symbol->method->accept(*this);
+  
+  return res;
+}
+
 void *function_param_iterator_c::visit(input_output_declarations_c *symbol) {
   TRACE("input_output_declarations_c");
   current_param_direction = direction_inout;
   return symbol->var_declaration_list->accept(*this);
 }
+
 void *function_param_iterator_c::visit(var_declaration_list_c *symbol) {TRACE("var_declaration_list_c"); return iterate_list(symbol);}
 
 /*  var1_list ':' array_specification */
@@ -425,12 +543,12 @@
 }
 
 
-
 void *function_param_iterator_c::visit(var1_list_c *symbol) {
   TRACE("var1_list_c");
   return handle_param_list(symbol);
 }
 
+
 void *function_param_iterator_c::visit(var_init_decl_list_c *symbol) {TRACE("var_init_decl_list_c"); return iterate_list(symbol);}
 
 
--- a/absyntax_utils/function_param_iterator.hh	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax_utils/function_param_iterator.hh	Thu Sep 08 20:25:00 2011 +0200
@@ -90,6 +90,16 @@
     symbol_c *current_param_default_value;
     param_direction_t current_param_direction;
     bool en_eno_param_implicit;
+    /* used when we reach an extensible parameter in the function declaration */
+    /* NOTE: this will handle syntax that is not in the standard.
+     *       It is used to handle the extensible standard functions
+     *       (e.g. AND(word#3, word#55, word#44); )
+     *       See absyntax.def or iec.y for more details.
+     */
+    bool current_param_is_extensible;
+    int  current_extensible_param_index;
+    int  _first_extensible_param_index;
+
     /* Which operation of the class was called...
      * Search a parameter, or iterate to the next parameter.
      */
@@ -97,6 +107,7 @@
     operation_t current_operation;
 
   private:
+    int   cmp_extparam_names(const char* s1, const char* s2);
     void* handle_param_list(list_c *list);
     void* handle_single_param(symbol_c *var_name);
 
@@ -128,7 +139,8 @@
     /* The seach() function does not in any way affect the internal state related 
      * to the iterate() function.
      * It will, however, affect the internal state necessary to correctly
-     * return the param_type() and default_value() of the found parameter.
+     * return the param_type(), default_value() and is_en_eno_param_implicit()
+     * of the found parameter.
      */
     identifier_c *search(symbol_c *param_name);
 
@@ -143,6 +155,16 @@
     /* Returns if currently referenced parameter is an implicit defined EN/ENO parameter. */
     bool is_en_eno_param_implicit(void);
 
+    /* Returns if currently referenced parameter is an extensible parameter. */
+    /* extensible paramters only occur in some standard functions, e.g. AND(word#34, word#44, word#65); */
+    bool is_extensible_param(void);
+    /* Returns the index of the current extensible parameter. */             
+    /* If the current parameter is not an extensible paramter, returns -1 */
+    int extensible_param_index(void);
+    /* Returns the index of the first extensible parameter, or -1 if no extensible parameter found. */             
+    /* WARNING: Will only return the correct value _after_ an extensible parameter has been found! */
+    int first_extensible_param_index(void);
+    
     /* Returns the currently referenced parameter's data passing direction.
      * i.e. VAR_INPUT, VAR_OUTPUT or VAR_INOUT
      */
--- a/absyntax_utils/search_expression_type.cc	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax_utils/search_expression_type.cc	Thu Sep 08 20:25:00 2011 +0200
@@ -202,11 +202,6 @@
 }
 
 
-integer_c search_expression_type_c::integer("1"); // what default value should we use here ???
-#include "search_type_code.c"
-
-/*static bool_type_name_c bool_type_name;*/
-
 /* A helper function... */
 void *search_expression_type_c::compute_boolean_expression(symbol_c *left_type, symbol_c *right_type) {
   if (!is_same_type(left_type, right_type))
@@ -385,13 +380,8 @@
 }
 
 void *search_expression_type_c::visit(function_invocation_c *symbol) {
-  function_declaration_c *f_decl = function_symtable.find_value(symbol->function_name);
-  if (f_decl == function_symtable.end_value()) {
-    void *res = compute_standard_function_default(symbol);
-    if (res == NULL)
-       ERROR;
-    return res;
-  }
+  function_declaration_c *f_decl = (function_declaration_c *)symbol->called_function_declaration;
+  if (f_decl == NULL) ERROR;
   return base_type(f_decl->type_name);
 }
 
--- a/absyntax_utils/search_expression_type.hh	Wed Sep 07 19:28:10 2011 +0200
+++ b/absyntax_utils/search_expression_type.hh	Thu Sep 08 20:25:00 2011 +0200
@@ -39,6 +39,18 @@
  *       etc...
  */
 
+/* WARNING   WARNING  WARNING
+ *
+ * When taking into consideration calls to functions, this search_expression_type_c
+ * class will use internal atributes (i.e. anotation) in the function_invocation_c symbol 
+ * in the abstract syntax tree.
+ *
+ * Since this anotation/atribute is only set/populated with the correct value
+ * during stage3 (semantic verification), this class will only work correctly
+ * after the semantic verification in stage 3 has been executed
+ * (to be more exact, the data type checking of stage 3).
+ */
+
 class search_expression_type_c: public search_constant_type_c {
 
   private:
--- a/absyntax_utils/search_type_code.c	Wed Sep 07 19:28:10 2011 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,29800 +0,0 @@
-/*
- * Copyright (C) 2007-2011: Edouard TISSERANT and Laurent BESSARD
- *
- * See COPYING and COPYING.LESSER files for copyright details.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-/****
- * IEC 61131-3 standard function library
- * generated code, do not edit by hand
- */
- 
- 
-
-void *search_expression_type_c::compute_standard_function_default(function_invocation_c *st_symbol = NULL, il_formal_funct_call_c *il_symbol = NULL) {
-  function_type_t current_function_type;
-  function_call_param_iterator_c *tmp_function_call_param_iterator;
-  if (st_symbol != NULL && il_symbol == NULL) {
-    current_function_type = get_function_type((identifier_c *)st_symbol->function_name);
-    tmp_function_call_param_iterator = new function_call_param_iterator_c(st_symbol);
-  }
-  else if (st_symbol == NULL && il_symbol != NULL) {
-    current_function_type = get_function_type((identifier_c *)il_symbol->function_name);
-    tmp_function_call_param_iterator = new function_call_param_iterator_c(il_symbol);
-  }
-  else
-    ERROR;
-  function_call_param_iterator_c function_call_param_iterator(*tmp_function_call_param_iterator);
-  search_expression_type_c* search_expression_type = this;
-
-  switch(current_function_type){
-
-/****
- *REAL_TO_SINT
- */
-    case function_real_to_sint :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_real_to_word*/
-    break;
-
-/****
- *REAL_TO_STRING
- */
-    case function_real_to_string :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::real_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::real_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::real_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_sint_to_real*/
-    break;
-
-/****
- *SINT_TO_LINT
- */
-    case function_sint_to_lint :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_sint_to_word*/
-    break;
-
-/****
- *SINT_TO_STRING
- */
-    case function_sint_to_string :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::sint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::sint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::sint_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_lint_to_sint*/
-    break;
-
-/****
- *LINT_TO_DINT
- */
-    case function_lint_to_dint :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_lint_to_word*/
-    break;
-
-/****
- *LINT_TO_STRING
- */
-    case function_lint_to_string :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::lint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::lint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::lint_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_dint_to_lint*/
-    break;
-
-/****
- *DINT_TO_DATE
- */
-    case function_dint_to_date :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_dint_to_word*/
-    break;
-
-/****
- *DINT_TO_STRING
- */
-    case function_dint_to_string :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_date_to_dint*/
-    break;
-
-/****
- *DATE_TO_DWORD
- */
-    case function_date_to_dword :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_date_to_dword*/
-    break;
-
-/****
- *DATE_TO_UDINT
- */
-    case function_date_to_udint :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_date_to_word*/
-    break;
-
-/****
- *DATE_TO_STRING
- */
-    case function_date_to_string :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_date_to_ulint*/
-    break;
-
-/****
- *DATE_TO_INT
- */
-    case function_date_to_int :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::date_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::date_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::date_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_dword_to_date*/
-    break;
-
-/****
- *DWORD_TO_DT
- */
-    case function_dword_to_dt :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_dword_to_word*/
-    break;
-
-/****
- *DWORD_TO_STRING
- */
-    case function_dword_to_string :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dword_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dword_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_dt_to_dint*/
-    break;
-
-/****
- *DT_TO_DWORD
- */
-    case function_dt_to_dword :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_dt_to_dword*/
-    break;
-
-/****
- *DT_TO_UDINT
- */
-    case function_dt_to_udint :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_dt_to_word*/
-    break;
-
-/****
- *DT_TO_STRING
- */
-    case function_dt_to_string :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_dt_to_ulint*/
-    break;
-
-/****
- *DT_TO_INT
- */
-    case function_dt_to_int :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::dt_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::dt_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::dint_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_tod_to_dint*/
-    break;
-
-/****
- *TOD_TO_DWORD
- */
-    case function_tod_to_dword :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::dword_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_tod_to_dword*/
-    break;
-
-/****
- *TOD_TO_UDINT
- */
-    case function_tod_to_udint :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_tod_to_word*/
-    break;
-
-/****
- *TOD_TO_STRING
- */
-    case function_tod_to_string :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::ulint_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_tod_to_ulint*/
-    break;
-
-/****
- *TOD_TO_INT
- */
-    case function_tod_to_int :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::tod_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::tod_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::tod_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_udint_to_tod*/
-    break;
-
-/****
- *UDINT_TO_WORD
- */
-    case function_udint_to_word :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                symbol_c * return_type_symbol = &search_constant_type_c::word_type_name;
-                return return_type_symbol;
-                
-            }
-            
-            
-            ERROR;
-        }
-        
-    }/*function_udint_to_word*/
-    break;
-
-/****
- *UDINT_TO_STRING
- */
-    case function_udint_to_string :
-    {
-        symbol_c *last_type_symbol = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_param_iterator.next_nf();
-            if (IN_param_value != NULL) {
-              IN_type_symbol = search_expression_type->get_type(IN_param_value);
-              last_type_symbol = last_type_symbol && IN_type_symbol && search_expression_type->is_same_type(IN_type_symbol, last_type_symbol) ? search_expression_type->common_type(IN_type_symbol, last_type_symbol) : IN_type_symbol ;
-            }
-            
-            if(IN_type_symbol == NULL || search_expression_type->is_same_type(&search_constant_type_c::udint_type_name, last_type_symbol))
-            {
-        
-                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 = &search_constant_type_c::udint_type_name;
-
-        {
-            symbol_c *IN_param_name = (symbol_c *)(new identifier_c("IN"));
-            /* Get the value from a foo(<param_name> = <param_value>) style call */
-            symbol_c *IN_param_value = function_call_param_iterator.search_f(IN_param_name);
-            symbol_c *IN_type_symbol = NULL;
-            
-            /* Get the value from a foo(<param_value>) style call */
-            if (IN_param_value == NULL)
-              IN_param_value = function_call_p