Index: autom4te.cache/requests
===================================================================
--- autom4te.cache/requests	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ autom4te.cache/requests	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -69,6 +69,6 @@
                         'AM_SET_DEPDIR' => 1,
                         '_AM_DEPENDENCIES' => 1,
+                        'm4_include' => 1,
                         'AM_PROG_INSTALL_SH' => 1,
-                        'm4_include' => 1,
                         '_AC_AM_CONFIG_HEADER_HOOK' => 1,
                         'AU_DEFUN' => 1,
@@ -88,53 +88,53 @@
                       ],
                       {
+                        'AM_PROG_F77_C_O' => 1,
                         '_LT_AC_TAGCONFIG' => 1,
-                        'AM_PROG_F77_C_O' => 1,
+                        'm4_pattern_forbid' => 1,
                         'AC_INIT' => 1,
-                        'm4_pattern_forbid' => 1,
+                        'AC_CANONICAL_TARGET' => 1,
                         '_AM_COND_IF' => 1,
-                        'AC_CANONICAL_TARGET' => 1,
+                        'AC_CONFIG_LIBOBJ_DIR' => 1,
                         'AC_SUBST' => 1,
-                        'AC_CONFIG_LIBOBJ_DIR' => 1,
+                        'AC_CANONICAL_HOST' => 1,
                         'AC_FC_SRCEXT' => 1,
-                        'AC_CANONICAL_HOST' => 1,
                         'AC_PROG_LIBTOOL' => 1,
                         'AM_INIT_AUTOMAKE' => 1,
+                        'AC_CONFIG_SUBDIRS' => 1,
                         'AM_PATH_GUILE' => 1,
-                        'AC_CONFIG_SUBDIRS' => 1,
                         'AM_AUTOMAKE_VERSION' => 1,
                         'LT_CONFIG_LTDL_DIR' => 1,
+                        'AC_CONFIG_LINKS' => 1,
                         'AC_REQUIRE_AUX_FILE' => 1,
-                        'AC_CONFIG_LINKS' => 1,
+                        'LT_SUPPORTED_TAG' => 1,
                         'm4_sinclude' => 1,
-                        'LT_SUPPORTED_TAG' => 1,
                         'AM_MAINTAINER_MODE' => 1,
                         'AM_NLS' => 1,
                         'AM_GNU_GETTEXT_INTL_SUBDIR' => 1,
+                        '_m4_warn' => 1,
                         'AM_MAKEFILE_INCLUDE' => 1,
-                        '_m4_warn' => 1,
                         'AM_PROG_CXX_C_O' => 1,
+                        '_AM_MAKEFILE_INCLUDE' => 1,
                         '_AM_COND_ENDIF' => 1,
-                        '_AM_MAKEFILE_INCLUDE' => 1,
                         'AM_ENABLE_MULTILIB' => 1,
                         'AM_SILENT_RULES' => 1,
                         'AM_PROG_MOC' => 1,
                         'AC_CONFIG_FILES' => 1,
+                        'LT_INIT' => 1,
                         'include' => 1,
-                        'LT_INIT' => 1,
+                        'AM_GNU_GETTEXT' => 1,
                         'AM_PROG_AR' => 1,
-                        'AM_GNU_GETTEXT' => 1,
                         'AC_LIBSOURCE' => 1,
+                        'AC_CANONICAL_BUILD' => 1,
                         'AM_PROG_FC_C_O' => 1,
-                        'AC_CANONICAL_BUILD' => 1,
                         'AC_FC_FREEFORM' => 1,
                         'AH_OUTPUT' => 1,
+                        'AC_CONFIG_AUX_DIR' => 1,
                         '_AM_SUBST_NOTMAKE' => 1,
-                        'AC_CONFIG_AUX_DIR' => 1,
+                        'm4_pattern_allow' => 1,
+                        'AM_PROG_CC_C_O' => 1,
                         'sinclude' => 1,
-                        'AM_PROG_CC_C_O' => 1,
-                        'm4_pattern_allow' => 1,
+                        'AM_CONDITIONAL' => 1,
+                        'AC_CANONICAL_SYSTEM' => 1,
                         'AM_XGETTEXT_OPTION' => 1,
-                        'AC_CANONICAL_SYSTEM' => 1,
-                        'AM_CONDITIONAL' => 1,
                         'AC_CONFIG_HEADERS' => 1,
                         'AC_DEFINE_TRACE_LITERAL' => 1,
Index: libcfa/Makefile.in
===================================================================
--- libcfa/Makefile.in	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ libcfa/Makefile.in	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -13,9 +13,11 @@
 
 # make forward declarations for gcc builtins
-builtins.cf: builtins.c builtins.def
+builtins.cf: Makefile builtins.c builtins.def
 	@BACKEND_CC@ -E builtins.c | sed 's/"//g' > builtins.cf
 
 libcfa-prelude.c: ../translator/cfa-cpp prelude.cf builtins.cf
+	sed -i -e "s#typedef.*ptrdiff_t.*#`@BACKEND_CC@ -E ptrdiff_t.c | grep 'typedef.*ptrdiff_t'`#" prelude.cf
 	../translator/cfa-cpp -l prelude.cf $@
+	rm -f prelude.c
 
 libcfa-prelude.o: libcfa-prelude.c
@@ -32,3 +34,2 @@
 
 distclean: clean
-
Index: libcfa/prelude.cf
===================================================================
--- libcfa/prelude.cf	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ libcfa/prelude.cf	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -1,101 +1,111 @@
-/*	Standard Cforall Preample
- *
- *	Copyright 1994, 1999	Glen Ditchfield
- *
- */
-
-// #include <stddef.h>
-typedef long _ptrdiff_t;
-
-/*
- * Section 4.1 Primary Expressions
- */
+//                               -*- Mode: C -*- 
+// 
+// Copyright (C) Glen Ditchfield 1994, 1999
+// 
+// prelude.cf -- Standard Cforall Preample
+// 
+// Author           : Glen Ditchfield
+// Created On       : Sat Nov 29 07:23:41 2014
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Dec  2 09:25:31 2014
+// Update Count     : 20
+//
+
+// Following line added from stddef.h by build
+typedef long int ptrdiff_t;
+
+// Section numbers from: http://plg.uwaterloo.ca/~cforall/refrat.pdf
+
+// ------------------------------------------------------------
+//
+// Section 4.1 Primary Expressions
+//
+// ------------------------------------------------------------
+
 const int 0, 1;
-/*
-const int 0;
-*/
-forall (dtype DT) const DT* const 	0;
-forall (ftype FT) FT * const 		0;
-
-/*
- * ------------------------------------------------------------
- *
- * Section 4.2 Postfix Operators
- */
-
-int		?++( int *),		?--( int *);
-unsigned	?++( unsigned *),	?--( unsigned *);
-long		?++( long *),		?--( long *);
-long unsigned	?++( long unsigned *),	?--( long unsigned *);
-float		?++( float *),		?--( float *);
-double		?++( double *),		?--( double *);
-long double	?++( long double *),	?--( long double *);
-
-forall(type T)	T*			?++(               T**);
-forall(type T)	T*			?--(               T**);
-forall(type T)	const T*		?++(const          T**);
-forall(type T)	const T*		?--(const          T**);
-forall(type T)	volatile T*		?++(      volatile T**);
-forall(type T)	volatile T*		?--(      volatile T**);
-forall(type T)	const volatile T*	?++(const volatile T**);
-forall(type T)	const volatile T*	?--(const volatile T**);
-
-forall(type T) lvalue T			?[?](               T*,	_ptrdiff_t);
-forall(type T) const lvalue T		?[?](const          T*,	_ptrdiff_t);
-forall(type T) volatile lvalue T	?[?](      volatile T*,	_ptrdiff_t);
-forall(type T) const volatile lvalue T	?[?](const volatile T*,	_ptrdiff_t);
-forall(type T) lvalue T			?[?](_ptrdiff_t,	               T*);
-forall(type T) const lvalue T		?[?](_ptrdiff_t,	const          T*);
-forall(type T) volatile lvalue T	?[?](_ptrdiff_t,	      volatile T*);
-forall(type T) const volatile lvalue T	?[?](_ptrdiff_t,	const volatile T*);
-
-/*
- * ------------------------------------------------------------
- *
- * Section 4.3 Unary Operators
- */
-
-int		++?(int *), 		--?(int *);
-unsigned	++?(unsigned *), 	--?(unsigned *);
-long		++?(long *), 		--?(long *);
-long unsigned	++?(long unsigned *), 	--?(long unsigned *);
-float		++?(float *), 		--?(float *);
-double		++?(double *),		--?(double *);
-long double	++?(long double *), 	--?(long double *);
-
-forall(type T) T*			++?(               T**);
-forall(type T) T*			--?(               T**);
-forall(type T) const T*			++?(const          T**);
-forall(type T) const T* 		--?(const          T**);
-forall(type T) volatile T*		++?(      volatile T**);
-forall(type T) volatile T* 		--?(      volatile T**);
-forall(type T) const volatile T*	++?(const volatile T**);
-forall(type T) const volatile T* 	--?(const volatile T**);
-
-forall(type T) lvalue T			*?(                T* );
-forall(type T) const lvalue T		*?( const          T* );
-forall(type T) volatile lvalue T	*?(       volatile T* );
-forall(type T) const volatile lvalue T	*?( const volatile T* );
-forall(ftype FT) lvalue FT			*?( FT* );
-
-int 		+?(int), 		-?(int), 		~?(int);
-unsigned 	+?(unsigned), 		-?(unsigned),		~?(unsigned);
-unsigned long	+?(unsigned long),	-?(unsigned long),      ~?(unsigned long);
-long 		+?(long), 		-?(long), 		~?(long);
-float		+?(float), 		-?(float);
-double 		+?(double), 		-?(double);
-long double 	+?(long double),	-?(long double);
+
+forall ( dtype DT ) const DT * const 	0;
+forall ( ftype FT ) FT * const 		0;
+
+// ------------------------------------------------------------
+//
+// Section 4.2 Postfix Operators
+//
+// ------------------------------------------------------------
+
+int		?++( int * ),		 ?--( int * );
+unsigned	?++( unsigned * ),	 ?--( unsigned * );
+long		?++( long * ),		 ?--( long * );
+long unsigned	?++( long unsigned * ),	 ?--( long unsigned * );
+float		?++( float * ),		 ?--( float * );
+double		?++( double * ),	 ?--( double * );
+long double	?++( long double * ),	 ?--( long double * );
+
+forall( type T ) T *			 ?++(		     T ** );
+forall( type T ) T *			 ?--(		     T ** );
+forall( type T ) const T *		 ?++( const	     T ** );
+forall( type T ) const T *		 ?--( const	     T ** );
+forall( type T ) volatile T *		 ?++(	    volatile T ** );
+forall( type T ) volatile T *		 ?--(	    volatile T ** );
+forall( type T ) const volatile T *	 ?++( const volatile T ** );
+forall( type T ) const volatile T *	 ?--( const volatile T ** );
+
+forall( type T ) lvalue T		 ?[?](		      T *,	     ptrdiff_t );
+forall( type T ) const lvalue T		 ?[?]( const	      T *,	     ptrdiff_t );
+forall( type T ) volatile lvalue T	 ?[?](       volatile T *,	     ptrdiff_t );
+forall( type T ) const volatile lvalue T ?[?]( const volatile T *,	     ptrdiff_t );
+forall( type T ) lvalue T		 ?[?]( ptrdiff_t,     T * );
+forall( type T ) const lvalue T		 ?[?]( ptrdiff_t,    const	     T * );
+forall( type T ) volatile lvalue T	 ?[?]( ptrdiff_t,    volatile	     T * );
+forall( type T ) const volatile lvalue T ?[?]( ptrdiff_t,    const volatile  T * );
+
+// ------------------------------------------------------------
+//
+// Section 4.3 Unary Operators
+//
+// ------------------------------------------------------------
+
+int		++?( int * ), 		 --?( int * );
+unsigned	++?( unsigned * ), 	 --?( unsigned * );
+long		++?( long * ), 		 --?( long * );
+long unsigned	++?( long unsigned * ),  --?( long unsigned * );
+float		++?( float * ), 	 --?( float * );
+double		++?( double * ),	 --?( double * );
+long double	++?( long double * ), 	 --?( long double * );
+
+forall( type T ) T *			 ++?(		     T ** );
+forall( type T ) T *			 --?(		     T ** );
+forall( type T ) const T *		 ++?( const	     T ** );
+forall( type T ) const T * 		 --?( const	     T ** );
+forall( type T ) volatile T *		 ++?(	    volatile T ** );
+forall( type T ) volatile T * 		 --?(	    volatile T ** );
+forall( type T ) const volatile T *	 ++?( const volatile T ** );
+forall( type T ) const volatile T * 	 --?( const volatile T ** );
+
+forall( type T ) lvalue T		 *?(		     T * );
+forall( type T ) const lvalue T		 *?( const	     T * );
+forall( type T ) volatile lvalue T	 *?(       volatile  T * );
+forall( type T ) const volatile lvalue T *?( const volatile  T * );
+forall( ftype FT ) lvalue FT		 *?( FT * );
+
+int 		+?( int ), 		 -?( int ), 		~?( int );
+unsigned 	+?( unsigned ), 	 -?( unsigned ),	~?( unsigned );
+unsigned long	+?( unsigned long ),	 -?( unsigned long ),	~?( unsigned long );
+long 		+?( long ), 		 -?( long ), 		~?( long );
+float		+?( float ), 		 -?( float );
+double 		+?( double ), 		 -?( double );
+long double 	+?( long double ),	 -?( long double );
 
 int	!?( int ),	!?( unsigned ),	!?( long ),	!?( unsigned long ),
     	!?( float ),	!?( double );
 
-forall (dtype DT) int !?( const volatile DT* );
-forall (ftype FT) int !?( FT* );
-
-/*
- * ------------------------------------------------------------
- *
- * Section 4.5 Multiplicative Operators
- */
+forall ( dtype DT ) int !?( const volatile DT * );
+forall ( ftype FT ) int !?( FT * );
+
+// ------------------------------------------------------------
+//
+// Section 4.5 Multiplicative Operators
+//
+// ------------------------------------------------------------
 
 int		?*?( int, int ),
@@ -117,115 +127,116 @@
 long double	?*?( long double, long double ),
     		?/?( long double, long double );
-/*
- * ------------------------------------------------------------
- *
- * Section 4.6 Additive Operators
- */
-
-int		?+?( int, int), 			?-?( int, int);
-long		?+?( long, long), 	 	  	?-?( long, long);
-unsigned	?+?( unsigned, unsigned), 	  	?-?( unsigned, unsigned);
-long unsigned	?+?( long unsigned, long unsigned), 	?-?( long unsigned, long unsigned);
-float		?+?( float, float), 		  	?-?( float, float);
-double		?+?( double, double), 		  	?-?( double, double);
-long double	?+?( long double, long double), 	?-?( long double, long double);
-
-forall(type T) T*	 		?+?(               T*,                       _ptrdiff_t);
-forall(type T) T*		        ?+?(               _ptrdiff_t,                T*);
-forall(type T) T*		        ?-?(               T*,                       _ptrdiff_t);
-forall(type T) const T*	 	        ?+?(const          T*,                       _ptrdiff_t);
-forall(type T) const T*			?+?(               _ptrdiff_t, const          T*);
-forall(type T) const T*			?-?(const          T*,                       _ptrdiff_t);
-forall(type T) volatile T*	 	?+?(      volatile T*,                       _ptrdiff_t);
-forall(type T) volatile T*		?+?(               _ptrdiff_t,       volatile T*);
-forall(type T) volatile T*		?-?(      volatile T*,                       _ptrdiff_t);
-forall(type T) const volatile T*	?+?(const volatile T*,                       _ptrdiff_t);
-forall(type T) const volatile T*        ?+?(               _ptrdiff_t, const volatile T*);
-forall(type T) const volatile T*        ?-?(const volatile T*, 	                   _ptrdiff_t);
-
-forall(type T) _ptrdiff_t	  ?-?(const volatile T*, const volatile T*);
-
-/*
- * ------------------------------------------------------------
- *
- * Section 4.7 Bitwise Shift Operators
- */
-
-int		?<<?(int, int), 			?>>?(int, int);
-long		?<<?(long, long), 			?>>?(long, long);
-unsigned	?<<?(unsigned, unsigned), 		?>>?(unsigned, unsigned);
-long unsigned	?<<?(long unsigned, long unsigned),	?>>?(long unsigned, long unsigned);
-
-/*
- * ------------------------------------------------------------
- *
- * Section 4.8 Relational Operators
- */
-
-int	?<?(int, int), 				?<=?(int, int),
-    	?>?(int, int), 				?>=?(int, int);
-int	?<?(long, long), 			?<=?(long, long),
-    	?>?(long, long), 			?>=?(long, long);
-int	?<?(unsigned, unsigned), 		?<=?(unsigned, unsigned),
-    	?>?(unsigned, unsigned), 		?>=?(unsigned, unsigned);
-int	?<?(unsigned long, unsigned long), 	?<=?(unsigned long, unsigned long),
-    	?>?(unsigned long, unsigned long), 	?>=?(unsigned long, unsigned long);
-int	?<?(float, float), 			?<=?(float, float),
-    	?>?(float, float), 			?>=?(float, float);
-int	?<?(double, double), 			?<=?(double, double),
-    	?>?(double, double), 			?>=?(double, double);
-int	?<?(long double, long double), 		?<=?(long double, long double),
-    	?>?(long double, long double), 		?>=?(long double, long double);
-
-forall(dtype DT) int ?<?( const volatile DT*, const volatile DT*);
-forall(dtype DT) int ?>?( const volatile DT*, const volatile DT*);
-forall(dtype DT) int ?<=?( const volatile DT*, const volatile DT*);
-forall(dtype DT) int ?>=?( const volatile DT*, const volatile DT*);
-
-/*
- * ------------------------------------------------------------
- *
- * Section 4.9 Equality Operators
- */
-
-int	?==?(int, int),				?!=?(int, int);
-int	?==?(long, long),			?!=?(long, long);
-int	?==?(unsigned, unsigned),		?!=?(unsigned, unsigned);
-int	?==?(unsigned long, unsigned long),	?!=?(unsigned long, unsigned long);
-int	?==?(float, float),			?!=?(float, float);
-int	?==?(double, double),			?!=?(double, double);
-int	?==?(long double, long double),		?!=?(long double, long double);
-
-forall(dtype DT) int ?==?(                DT*,                DT*);
-forall(dtype DT) int ?!=?(                DT*,                DT*);
-forall(dtype DT) int ?==?( const          DT*, const          DT*);
-forall(dtype DT) int ?!=?( const          DT*, const          DT*);
-forall(dtype DT) int ?==?(       volatile DT*,       volatile DT*);
-forall(dtype DT) int ?!=?(       volatile DT*,       volatile DT*);
-forall(dtype DT) int ?==?( const volatile DT*, const volatile DT*);
-forall(dtype DT) int ?!=?( const volatile DT*, const volatile DT*);
-forall(ftype FT) int ?==?( FT*, FT*);
-forall(ftype FT) int ?!=?( FT*, FT*);
-
-
-forall(dtype DT) int ?==?( const volatile DT*, const volatile void*);
-forall(dtype DT) int ?!=?( const volatile DT*, const volatile void*);
-forall(dtype DT) int ?==?( const volatile void*, const volatile DT*);
-forall(dtype DT) int ?!=?( const volatile void*, const volatile DT*);
-
-forall(dtype DT) int ?==?( const volatile DT*, forall(dtype DT2)const DT2*);
-forall(dtype DT) int ?!=?( const volatile DT*, forall(dtype DT2)const DT2*);
-forall(dtype DT) int ?==?( forall(dtype DT2)const DT2*, const volatile DT*);
-forall(dtype DT) int ?!=?( forall(dtype DT2)const DT2*, const volatile DT*);
-forall(ftype FT) int ?==?( FT*, forall(ftype FT2)FT2*);
-forall(ftype FT) int ?!=?( FT*, forall(ftype FT2)FT2*);
-forall(ftype FT) int ?==?( forall(ftype FT2)FT2*, FT*);
-forall(ftype FT) int ?!=?( forall(ftype FT2)FT2*, FT*);
-
-/*
- * ------------------------------------------------------------
- *
- * Section 4.10 Bitwise AND Operators
- */
+
+// ------------------------------------------------------------
+//
+// Section 4.6 Additive Operators
+//
+// ------------------------------------------------------------
+
+int		?+?( int, int ), 			?-?( int, int );
+long		?+?( long, long ), 	 	  	?-?( long, long );
+unsigned	?+?( unsigned, unsigned ), 	  	?-?( unsigned, unsigned );
+long unsigned	?+?( long unsigned, long unsigned ), 	?-?( long unsigned, long unsigned );
+float		?+?( float, float ), 		  	?-?( float, float );
+double		?+?( double, double ), 		  	?-?( double, double );
+long double	?+?( long double, long double ), 	?-?( long double, long double );
+
+forall( type T ) T *	 		?+?(		    T *,		       ptrdiff_t );
+forall( type T ) T *			?+?(	      ptrdiff_t,		       T * );
+forall( type T ) T *			?-?(		    T *,		       ptrdiff_t );
+forall( type T ) const T *		?+?( const	    T *,		       ptrdiff_t );
+forall( type T ) const T *		?+?(	      ptrdiff_t, const	       T * );
+forall( type T ) const T *		?-?( const	    T *,		       ptrdiff_t );
+forall( type T ) volatile T *		?+?(	   volatile T *,		       ptrdiff_t );
+forall( type T ) volatile T *		?+?(	      ptrdiff_t,	      volatile T * );
+forall( type T ) volatile T *		?-?(	   volatile T *,		       ptrdiff_t );
+forall( type T ) const volatile T *	?+?( const volatile T *,		       ptrdiff_t );
+forall( type T ) const volatile T *	?+?(	      ptrdiff_t, const volatile T * );
+forall( type T ) const volatile T *	?-?( const volatile T *,		       ptrdiff_t );
+
+forall( type T ) ptrdiff_t		?-?( const volatile T *, const volatile T * );
+
+// ------------------------------------------------------------
+//
+// Section 4.7 Bitwise Shift Operators
+//
+// ------------------------------------------------------------
+
+int		?<<?( int, int ), 			?>>?( int, int );
+long		?<<?( long, long ), 			?>>?( long, long );
+unsigned	?<<?( unsigned, unsigned ), 		?>>?( unsigned, unsigned );
+long unsigned	?<<?( long unsigned, long unsigned ),	?>>?( long unsigned, long unsigned );
+
+// ------------------------------------------------------------
+//
+// Section 4.8 Relational Operators
+//
+// ------------------------------------------------------------
+
+int	?<?( int, int ), 			?<=?( int, int ),
+    	?>?( int, int ), 			?>=?( int, int );
+int	?<?( long, long ), 			?<=?( long, long ),
+    	?>?( long, long ), 			?>=?( long, long );
+int	?<?( unsigned, unsigned ), 		?<=?( unsigned, unsigned ),
+    	?>?( unsigned, unsigned ), 		?>=?( unsigned, unsigned );
+int	?<?( unsigned long, unsigned long ), 	?<=?( unsigned long, unsigned long ),
+    	?>?( unsigned long, unsigned long ), 	?>=?( unsigned long, unsigned long );
+int	?<?( float, float ), 			?<=?( float, float ),
+    	?>?( float, float ), 			?>=?( float, float );
+int	?<?( double, double ), 			?<=?( double, double ),
+    	?>?( double, double ), 			?>=?( double, double );
+int	?<?( long double, long double ), 	?<=?( long double, long double ),
+    	?>?( long double, long double ), 	?>=?( long double, long double );
+
+forall( dtype DT ) int ?<?(  const volatile DT *, const volatile DT * );
+forall( dtype DT ) int ?>?(  const volatile DT *, const volatile DT * );
+forall( dtype DT ) int ?<=?( const volatile DT *, const volatile DT * );
+forall( dtype DT ) int ?>=?( const volatile DT *, const volatile DT * );
+
+// ------------------------------------------------------------
+//
+// Section 4.9 Equality Operators
+//
+// ------------------------------------------------------------
+
+int	?==?( int, int ),			?!=?( int, int );
+int	?==?( long, long ),			?!=?( long, long );
+int	?==?( unsigned, unsigned ),		?!=?( unsigned, unsigned );
+int	?==?( unsigned long, unsigned long ),	?!=?( unsigned long, unsigned long );
+int	?==?( float, float ),			?!=?( float, float );
+int	?==?( double, double ),			?!=?( double, double );
+int	?==?( long double, long double ),	?!=?( long double, long double );
+
+forall( dtype DT ) int ?==?(		    DT *,		 DT * );
+forall( dtype DT ) int ?!=?(		    DT *,		 DT * );
+forall( dtype DT ) int ?==?( const	    DT *, const		 DT * );
+forall( dtype DT ) int ?!=?( const	    DT *, const		 DT * );
+forall( dtype DT ) int ?==?(       volatile DT *,       volatile DT * );
+forall( dtype DT ) int ?!=?(       volatile DT *,       volatile DT * );
+forall( dtype DT ) int ?==?( const volatile DT *, const volatile DT * );
+forall( dtype DT ) int ?!=?( const volatile DT *, const volatile DT * );
+forall( ftype FT ) int ?==?( FT *, FT * );
+forall( ftype FT ) int ?!=?( FT *, FT * );
+
+
+forall( dtype DT ) int ?==?( const volatile DT   *, const volatile void * );
+forall( dtype DT ) int ?!=?( const volatile DT   *, const volatile void * );
+forall( dtype DT ) int ?==?( const volatile void *, const volatile DT * );
+forall( dtype DT ) int ?!=?( const volatile void *, const volatile DT * );
+
+forall( dtype DT ) int ?==?( const volatile DT *, forall( dtype DT2 )const DT2 * );
+forall( dtype DT ) int ?!=?( const volatile DT *, forall( dtype DT2 )const DT2 * );
+forall( dtype DT ) int ?==?( forall( dtype DT2 )const DT2 *, const volatile DT * );
+forall( dtype DT ) int ?!=?( forall( dtype DT2 )const DT2 *, const volatile DT * );
+forall( ftype FT ) int ?==?( FT *, forall( ftype FT2 )FT2 * );
+forall( ftype FT ) int ?!=?( FT *, forall( ftype FT2 )FT2 * );
+forall( ftype FT ) int ?==?( forall( ftype FT2 )FT2 *, FT * );
+forall( ftype FT ) int ?!=?( forall( ftype FT2 )FT2 *, FT * );
+
+// ------------------------------------------------------------
+//
+// Section 4.10 Bitwise AND Operators
+//
+// ------------------------------------------------------------
 
 int		?&?( int, int );
@@ -234,9 +245,9 @@
 unsigned long	?&?( unsigned long, unsigned long );
 
-/*
- * ------------------------------------------------------------
- *
- * Section 4.11 Bitwise XOR Operators
- */
+// ------------------------------------------------------------
+//
+// Section 4.11 Bitwise XOR Operators
+//
+// ------------------------------------------------------------
 
 int		?^?( int, int );
@@ -245,9 +256,9 @@
 unsigned long	?^?( unsigned long, unsigned long );
 
-/*
- * ------------------------------------------------------------
- *
- * Section 4.12 Bitwise OR Operators
- */
+// ------------------------------------------------------------
+//
+// Section 4.12 Bitwise OR Operators
+//
+// ------------------------------------------------------------
 
 int		?|?( int, int );
@@ -256,414 +267,426 @@
 unsigned long	?|?( unsigned long, unsigned long );
 
-/*
- * ------------------------------------------------------------
- *
- * Section 4.16 Assignment Operator
- */
-
-forall(ftype FT) FT*           ?=?(FT**, FT*);
-forall(ftype FT) FT*           ?=?(FT* volatile*, FT*);
-
-forall(dtype DT) DT* 		   	?=?(                DT *          *,          DT* );
-forall(dtype DT) DT* 		   	?=?(                DT * volatile *, 	             DT* );
-forall(dtype DT) const DT* 	   	?=?(const           DT *          *,                DT* );
-forall(dtype DT) const DT*	        ?=?(const           DT * volatile *,                DT* );
-forall(dtype DT) const DT*              ?=?(const           DT *          *, const          DT* );
-forall(dtype DT) const DT*              ?=?(const           DT * volatile *, const          DT* );
-forall(dtype DT) volatile DT* 	   	?=?(      volatile  DT *          *,                DT* );
-forall(dtype DT) volatile DT*           ?=?(      volatile  DT * volatile *,                DT* );
-forall(dtype DT) volatile DT*           ?=?(      volatile  DT *          *,       volatile DT* );
-forall(dtype DT) volatile DT*           ?=?(      volatile  DT * volatile *,       volatile DT* );
+// ------------------------------------------------------------
+//
+// Section 4.16 Assignment Operator
+//
+// ------------------------------------------------------------
+
+forall( ftype FT ) FT *			?=?( FT **, FT * );
+forall( ftype FT ) FT *			?=?( FT * volatile *, FT * );
+
+forall( dtype DT ) DT * 		?=?(		     DT *	   *,			DT * );
+forall( dtype DT ) DT * 		?=?(		     DT * volatile *, 			DT * );
+forall( dtype DT ) const DT * 	   	?=?( const	     DT *	   *,			DT * );
+forall( dtype DT ) const DT *		?=?( const	     DT * volatile *,			DT * );
+forall( dtype DT ) const DT *	    	?=?( const	     DT *	   *, const		DT * );
+forall( dtype DT ) const DT *	   	?=?( const	     DT * volatile *, const		DT * );
+forall( dtype DT ) volatile DT * 	?=?(	   volatile  DT *	   *,			DT * );
+forall( dtype DT ) volatile DT *	?=?(	   volatile  DT * volatile *,			DT * );
+forall( dtype DT ) volatile DT *	?=?(	   volatile  DT *	   *,	    volatile	DT * );
+forall( dtype DT ) volatile DT *	?=?(	   volatile  DT * volatile *,	    volatile	DT * );
 	
-forall(dtype DT) const volatile DT*	?=?(const volatile  DT *          *,                DT* );
-forall(dtype DT) const volatile DT*     ?=?(const volatile  DT * volatile *,                DT* );
-forall(dtype DT) const volatile DT*     ?=?(const volatile  DT *          *, const          DT* );
-forall(dtype DT) const volatile DT*     ?=?(const volatile  DT * volatile *, const          DT* );
-forall(dtype DT) const volatile DT*     ?=?(const volatile  DT *          *,       volatile DT* );
-forall(dtype DT) const volatile DT*     ?=?(const volatile  DT * volatile *,       volatile DT* );
-forall(dtype DT) const volatile DT*     ?=?(const volatile  DT *          *, const volatile DT* );
-forall(dtype DT) const volatile DT*    ?=?(const volatile  DT * volatile *, const volatile DT* );
-
-forall(dtype DT) DT* 		   	?=?(                DT *          *,          void* );
-forall(dtype DT) DT* 		   	?=?(                DT * volatile *, 	             void* );
-forall(dtype DT) const DT* 	   	?=?(const           DT *          *,                void* );
-forall(dtype DT) const DT*	        ?=?(const           DT * volatile *,                void* );
-forall(dtype DT) const DT*              ?=?(const           DT *          *, const          void* );
-forall(dtype DT) const DT*              ?=?(const           DT * volatile *, const          void* );
-forall(dtype DT) volatile DT* 	   	?=?(      volatile  DT *          *,                void* );
-forall(dtype DT) volatile DT*           ?=?(      volatile  DT * volatile *,                void* );
-forall(dtype DT) volatile DT*           ?=?(      volatile  DT *          *,       volatile void* );
-forall(dtype DT) volatile DT*           ?=?(      volatile  DT * volatile *,       volatile void* );
+forall( dtype DT ) const volatile DT *	?=?( const volatile  DT *	   *,			DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile *,			DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *	   *, const		DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile *, const		DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *	   *,	    volatile	DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile *,	    volatile	DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *	   *, const volatile	DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile *, const volatile	DT * );
+
+forall( dtype DT ) DT * 		?=?(		     DT *	   *,			void * );
+forall( dtype DT ) DT * 		?=?(		     DT * volatile *, 			void * );
+forall( dtype DT ) const DT *		?=?( const	     DT *	   *,			void * );
+forall( dtype DT ) const DT *		?=?( const	     DT * volatile *,			void * );
+forall( dtype DT ) const DT *		?=?( const	     DT *	   *, const		void * );
+forall( dtype DT ) const DT *		?=?( const	     DT * volatile *, const	  	void * );
+forall( dtype DT ) volatile DT * 	?=?(	   volatile  DT *	   *,			void * );
+forall( dtype DT ) volatile DT *	?=?(	   volatile  DT * volatile *,			void * );
+forall( dtype DT ) volatile DT *	?=?(	   volatile  DT *	   *,	    volatile	void * );
+forall( dtype DT ) volatile DT *	?=?(	   volatile  DT * volatile *,	    volatile	void * );
 	
-forall(dtype DT) const volatile DT*	?=?(const volatile  DT *          *,                void* );
-forall(dtype DT) const volatile DT*     ?=?(const volatile  DT * volatile *,                void* );
-forall(dtype DT) const volatile DT*     ?=?(const volatile  DT *          *, const          void* );
-forall(dtype DT) const volatile DT*     ?=?(const volatile  DT * volatile *, const          void* );
-forall(dtype DT) const volatile DT*     ?=?(const volatile  DT *          *,       volatile void* );
-forall(dtype DT) const volatile DT*     ?=?(const volatile  DT * volatile *,       volatile void* );
-forall(dtype DT) const volatile DT*     ?=?(const volatile  DT *          *, const volatile void* );
-forall(dtype DT) const volatile DT*    ?=?(const volatile  DT * volatile *, const volatile void* );
-
-	
-forall(dtype DT) void *		   ?=?(               void *          *,                DT*);
-forall(dtype DT) void *            ?=?(               void * volatile *,                DT*);
-forall(dtype DT) const void *	   ?=?(const          void *          *,                DT*);
-forall(dtype DT) const void *      ?=?(const          void * volatile *,                DT*);
-forall(dtype DT) const void *      ?=?(const          void *          *, const          DT*);
-forall(dtype DT) const void *      ?=?(const          void * volatile *, const          DT*);
-forall(dtype DT) volatile void *   ?=?(      volatile void *          *,                DT*);
-forall(dtype DT) volatile void *   ?=?(      volatile void * volatile *,                DT*);
-forall(dtype DT) volatile void *   ?=?(      volatile void *          *,       volatile DT*);
-forall(dtype DT) volatile void *   ?=?(      volatile void * volatile *,       volatile DT*);
-forall(dtype DT) const volatile void *   ?=?(const volatile void *          *,                DT*);
-forall(dtype DT) const volatile void *   ?=?(const volatile void * volatile *,                DT*);
-forall(dtype DT) const volatile void *   ?=?(const volatile void *          *, const          DT*);
-forall(dtype DT) const volatile void *   ?=?(const volatile void * volatile *, const          DT*);
-forall(dtype DT) const volatile void *   ?=?(const volatile void *          *,       volatile DT*);
-forall(dtype DT) const volatile void *   ?=?(const volatile void * volatile *,       volatile DT*);
-forall(dtype DT) const volatile void *   ?=?(const volatile void *          *, const volatile DT*);
-forall(dtype DT) const volatile void *   ?=?(const volatile void * volatile *, const volatile DT*);
-
-void *		  ?=?(               void *          *,                void*);
-void *            ?=?(               void * volatile *,                void*);
-const void *	  ?=?(const          void *          *,                void*);
-const void *      ?=?(const          void * volatile *,                void*);
-const void *      ?=?(const          void *          *, const          void*);
-const void *      ?=?(const          void * volatile *, const          void*);
-volatile void *   ?=?(      volatile void *          *,                void*);
-volatile void *   ?=?(      volatile void * volatile *,                void*);
-volatile void *   ?=?(      volatile void *          *,       volatile void*);
-volatile void *   ?=?(      volatile void * volatile *,       volatile void*);
-const volatile void *   ?=?(const volatile void *          *,                void*);
-const volatile void *   ?=?(const volatile void * volatile *,                void*);
-const volatile void *   ?=?(const volatile void *          *, const          void*);
-const volatile void *   ?=?(const volatile void * volatile *, const          void*);
-const volatile void *   ?=?(const volatile void *          *,       volatile void*);
-const volatile void *   ?=?(const volatile void * volatile *,       volatile void*);
-const volatile void *   ?=?(const volatile void *          *, const volatile void*);
-const volatile void *   ?=?(const volatile void * volatile *, const volatile void*);
-
-forall(dtype DT) DT*		   ?=?(               DT *          *, forall(dtype DT2) const DT2*);
-forall(dtype DT) DT*               ?=?(               DT * volatile *, forall(dtype DT2) const DT2*);
-forall(dtype DT) const DT*	   ?=?(const          DT *          *, forall(dtype DT2) const DT2*);
-forall(dtype DT) const DT*         ?=?(const          DT * volatile *, forall(dtype DT2) const DT2*);
-forall(dtype DT) volatile DT*	   ?=?(      volatile DT *          *, forall(dtype DT2) const DT2*);
-forall(dtype DT) volatile DT*      ?=?(      volatile DT * volatile *, forall(dtype DT2) const DT2*);
-forall(dtype DT) const volatile DT* ?=?(const volatile DT *          *, forall(dtype DT2) const DT2*);
-forall(dtype DT) const volatile DT* ?=?(const volatile DT * volatile *, forall(dtype DT2) const DT2*);
-
-forall(ftype FT) FT* 		   ?=?( FT *          *, forall(ftype FT2)FT2*);
-forall(ftype FT) FT*               ?=?( FT * volatile *, forall(ftype FT2)FT2*);
-
-forall(type T) T* 		   ?+=?(                T *          *, _ptrdiff_t);
-forall(type T) T*                  ?+=?(                T * volatile *, _ptrdiff_t);
-forall(type T) T*                  ?-=?(                T *          *, _ptrdiff_t);
-forall(type T) T*                  ?-=?(                T * volatile *, _ptrdiff_t);
-forall(type T) const T* 	   ?+=?( const          T *          *, _ptrdiff_t);
-forall(type T) const T*            ?+=?( const          T * volatile *, _ptrdiff_t);
-forall(type T) const T*            ?-=?( const          T *          *, _ptrdiff_t);
-forall(type T) const T*            ?-=?( const          T * volatile *, _ptrdiff_t);
-forall(type T) volatile T*	   ?+=?(       volatile T *          *, _ptrdiff_t);
-forall(type T) volatile T*         ?+=?(       volatile T * volatile *, _ptrdiff_t);
-forall(type T) volatile T*         ?-=?(       volatile T *          *, _ptrdiff_t);
-forall(type T) volatile T*         ?-=?(       volatile T * volatile *, _ptrdiff_t);
-forall(type T) const volatile T*   ?+=?( const volatile T *          *, _ptrdiff_t);
-forall(type T) const volatile T*   ?+=?( const volatile T * volatile *, _ptrdiff_t);
-forall(type T) const volatile T*   ?-=?( const volatile T *          *, _ptrdiff_t);
-forall(type T) const volatile T*   ?-=?( const volatile T * volatile *, _ptrdiff_t);
-
-
-char			?=?(         char*, char),
-    			?=?(volatile char*, char);
-signed char		?=?(         signed char*, signed char),
-    			?=?(volatile signed char*, signed char);
-unsigned char		?=?(         unsigned char*, unsigned char),
-    			?=?(volatile unsigned char*, unsigned char);
-short			?=?(         short*, short),
-    			?=?(volatile short*, short);
-unsigned short		?=?(         unsigned short*, unsigned short),
-    			?=?(volatile unsigned short*, unsigned short);
-int			?=?(         int*, int),
-    			?=?(volatile int*, int);
-unsigned		?=?(         unsigned*, unsigned),
-    			?=?(volatile unsigned*, unsigned);
-long			?=?(         long*, long),
-    			?=?(volatile long*, long);
-unsigned long		?=?(         unsigned long*, unsigned long),
-    			?=?(volatile unsigned long*, unsigned long);
-long long			?=?(         long long*, long long),
-    			?=?(volatile long long*, long long);
-unsigned long long		?=?(         unsigned long long*, unsigned long long),
-    			?=?(volatile unsigned long long*, unsigned long long);
-
-char			?*=?(         char*, char),
-    			?*=?(volatile char*, char);
-signed char		?*=?(         signed char*, signed char),
-    			?*=?(volatile signed char*, signed char);
-unsigned char		?*=?(         unsigned char*, unsigned char),
-    			?*=?(volatile unsigned char*, unsigned char);
-short			?*=?(         short*, short),
-    			?*=?(volatile short*, short);
-unsigned short		?*=?(         unsigned short*, unsigned short),
-    			?*=?(volatile unsigned short*, unsigned short);
-int			?*=?(         int*, int),
-    			?*=?(volatile int*, int);
-unsigned		?*=?(         unsigned*, unsigned),
-    			?*=?(volatile unsigned*, unsigned);
-long			?*=?(         long*, long),
-    			?*=?(volatile long*, long);
-unsigned long		?*=?(         unsigned long*, unsigned long),
-    			?*=?(volatile unsigned long*, unsigned long);
-long long			?*=?(         long long*, long long),
-    			?*=?(volatile long long*, long long);
-unsigned long long		?*=?(         unsigned long long*, unsigned long long),
-    			?*=?(volatile unsigned long long*, unsigned long long);
-
-char			?/=?(         char*, char),
-    			?/=?(volatile char*, char);
-signed char		?/=?(         signed char*, signed char),
-    			?/=?(volatile signed char*, signed char);
-unsigned char		?/=?(         unsigned char*, unsigned char),
-    			?/=?(volatile unsigned char*, unsigned char);
-short			?/=?(         short*, short),
-    			?/=?(volatile short*, short);
-unsigned short		?/=?(         unsigned short*, unsigned short),
-    			?/=?(volatile unsigned short*, unsigned short);
-int			?/=?(         int*, int),
-    			?/=?(volatile int*, int);
-unsigned		?/=?(         unsigned*, unsigned),
-    			?/=?(volatile unsigned*, unsigned);
-long			?/=?(         long*, long),
-    			?/=?(volatile long*, long);
-unsigned long		?/=?(         unsigned long*, unsigned long),
-    			?/=?(volatile unsigned long*, unsigned long);
-long long			?/=?(         long long*, long long),
-    			?/=?(volatile long long*, long long);
-unsigned long long		?/=?(         unsigned long long*, unsigned long long),
-    			?/=?(volatile unsigned long long*, unsigned long long);
-
-char			?%=?(         char*, char),
-    			?%=?(volatile char*, char);
-signed char		?%=?(         signed char*, signed char),
-    			?%=?(volatile signed char*, signed char);
-unsigned char		?%=?(         unsigned char*, unsigned char),
-    			?%=?(volatile unsigned char*, unsigned char);
-short			?%=?(         short*, short),
-    			?%=?(volatile short*, short);
-unsigned short		?%=?(         unsigned short*, unsigned short),
-    			?%=?(volatile unsigned short*, unsigned short);
-int			?%=?(         int*, int),
-    			?%=?(volatile int*, int);
-unsigned		?%=?(         unsigned*, unsigned),
-    			?%=?(volatile unsigned*, unsigned);
-long			?%=?(         long*, long),
-    			?%=?(volatile long*, long);
-unsigned long		?%=?(         unsigned long*, unsigned long),
-    			?%=?(volatile unsigned long*, unsigned long);
-long long			?%=?(         long long*, long long),
-    			?%=?(volatile long long*, long long);
-unsigned long long		?%=?(         unsigned long long*, unsigned long long),
-    			?%=?(volatile unsigned long long*, unsigned long long);
-
-char			?+=?(         char*, char),
-    			?+=?(volatile char*, char);
-signed char		?+=?(         signed char*, signed char),
-    			?+=?(volatile signed char*, signed char);
-unsigned char		?+=?(         unsigned char*, unsigned char),
-    			?+=?(volatile unsigned char*, unsigned char);
-short			?+=?(         short*, short),
-    			?+=?(volatile short*, short);
-unsigned short		?+=?(         unsigned short*, unsigned short),
-    			?+=?(volatile unsigned short*, unsigned short);
-int			?+=?(         int*, int),
-    			?+=?(volatile int*, int);
-unsigned		?+=?(         unsigned*, unsigned),
-    			?+=?(volatile unsigned*, unsigned);
-long			?+=?(         long*, long),
-    			?+=?(volatile long*, long);
-unsigned long		?+=?(         unsigned long*, unsigned long),
-    			?+=?(volatile unsigned long*, unsigned long);
-long long			?+=?(         long long*, long long),
-    			?+=?(volatile long long*, long long);
-unsigned long long		?+=?(         unsigned long long*, unsigned long long),
-    			?+=?(volatile unsigned long long*, unsigned long long);
-
-char			?-=?(         char*, char),
-    			?-=?(volatile char*, char);
-signed char		?-=?(         signed char*, signed char),
-    			?-=?(volatile signed char*, signed char);
-unsigned char		?-=?(         unsigned char*, unsigned char),
-    			?-=?(volatile unsigned char*, unsigned char);
-short			?-=?(         short*, short),
-    			?-=?(volatile short*, short);
-unsigned short		?-=?(         unsigned short*, unsigned short),
-    			?-=?(volatile unsigned short*, unsigned short);
-int			?-=?(         int*, int),
-    			?-=?(volatile int*, int);
-unsigned		?-=?(         unsigned*, unsigned),
-    			?-=?(volatile unsigned*, unsigned);
-long			?-=?(         long*, long),
-    			?-=?(volatile long*, long);
-unsigned long		?-=?(         unsigned long*, unsigned long),
-    			?-=?(volatile unsigned long*, unsigned long);
-long long			?-=?(         long long*, long long),
-    			?-=?(volatile long long*, long long);
-unsigned long long		?-=?(         unsigned long long*, unsigned long long),
-    			?-=?(volatile unsigned long long*, unsigned long long);
-
-char			?<<=?(         char*, char),
-    			?<<=?(volatile char*, char);
-signed char		?<<=?(         signed char*, signed char),
-    			?<<=?(volatile signed char*, signed char);
-unsigned char		?<<=?(         unsigned char*, unsigned char),
-    			?<<=?(volatile unsigned char*, unsigned char);
-short			?<<=?(         short*, short),
-    			?<<=?(volatile short*, short);
-unsigned short		?<<=?(         unsigned short*, unsigned short),
-    			?<<=?(volatile unsigned short*, unsigned short);
-int			?<<=?(         int*, int),
-    			?<<=?(volatile int*, int);
-unsigned		?<<=?(         unsigned*, unsigned),
-    			?<<=?(volatile unsigned*, unsigned);
-long			?<<=?(         long*, long),
-    			?<<=?(volatile long*, long);
-unsigned long		?<<=?(         unsigned long*, unsigned long),
-    			?<<=?(volatile unsigned long*, unsigned long);
-long long			?<<=?(         long long*, long long),
-    			?<<=?(volatile long long*, long long);
-unsigned long long		?<<=?(         unsigned long long*, unsigned long long),
-    			?<<=?(volatile unsigned long long*, unsigned long long);
-
-char			?>>=?(         char*, char),
-    			?>>=?(volatile char*, char);
-signed char		?>>=?(         signed char*, signed char),
-    			?>>=?(volatile signed char*, signed char);
-unsigned char		?>>=?(         unsigned char*, unsigned char),
-    			?>>=?(volatile unsigned char*, unsigned char);
-short			?>>=?(         short*, short),
-    			?>>=?(volatile short*, short);
-unsigned short		?>>=?(         unsigned short*, unsigned short),
-    			?>>=?(volatile unsigned short*, unsigned short);
-int			?>>=?(         int*, int),
-    			?>>=?(volatile int*, int);
-unsigned		?>>=?(         unsigned*, unsigned),
-    			?>>=?(volatile unsigned*, unsigned);
-long			?>>=?(         long*, long),
-    			?>>=?(volatile long*, long);
-unsigned long		?>>=?(         unsigned long*, unsigned long),
-    			?>>=?(volatile unsigned long*, unsigned long);
-long long			?>>=?(         long long*, long long),
-    			?>>=?(volatile long long*, long long);
-unsigned long long		?>>=?(         unsigned long long*, unsigned long long),
-    			?>>=?(volatile unsigned long long*, unsigned long long);
-
-char			?&=?(         char*, char),
-    			?&=?(volatile char*, char);
-signed char		?&=?(         signed char*, signed char),
-    			?&=?(volatile signed char*, signed char);
-unsigned char		?&=?(         unsigned char*, unsigned char),
-    			?&=?(volatile unsigned char*, unsigned char);
-short			?&=?(         short*, short),
-    			?&=?(volatile short*, short);
-unsigned short		?&=?(         unsigned short*, unsigned short),
-    			?&=?(volatile unsigned short*, unsigned short);
-int			?&=?(         int*, int),
-    			?&=?(volatile int*, int);
-unsigned		?&=?(         unsigned*, unsigned),
-    			?&=?(volatile unsigned*, unsigned);
-long			?&=?(         long*, long),
-    			?&=?(volatile long*, long);
-unsigned long		?&=?(         unsigned long*, unsigned long),
-    			?&=?(volatile unsigned long*, unsigned long);
-long long			?&=?(         long long*, long long),
-    			?&=?(volatile long long*, long long);
-unsigned long long		?&=?(         unsigned long long*, unsigned long long),
-    			?&=?(volatile unsigned long long*, unsigned long long);
-
-char			?|=?(         char*, char),
-    			?|=?(volatile char*, char);
-signed char		?|=?(         signed char*, signed char),
-    			?|=?(volatile signed char*, signed char);
-unsigned char		?|=?(         unsigned char*, unsigned char),
-    			?|=?(volatile unsigned char*, unsigned char);
-short			?|=?(         short*, short),
-    			?|=?(volatile short*, short);
-unsigned short		?|=?(         unsigned short*, unsigned short),
-    			?|=?(volatile unsigned short*, unsigned short);
-int			?|=?(         int*, int),
-    			?|=?(volatile int*, int);
-unsigned		?|=?(         unsigned*, unsigned),
-    			?|=?(volatile unsigned*, unsigned);
-long			?|=?(         long*, long),
-    			?|=?(volatile long*, long);
-unsigned long		?|=?(         unsigned long*, unsigned long),
-    			?|=?(volatile unsigned long*, unsigned long);
-long long			?|=?(         long long*, long long),
-    			?|=?(volatile long long*, long long);
-unsigned long long		?|=?(         unsigned long long*, unsigned long long),
-    			?|=?(volatile unsigned long long*, unsigned long long);
-
-char			?^=?(         char*, char),
-    			?^=?(volatile char*, char);
-signed char		?^=?(         signed char*, signed char),
-    			?^=?(volatile signed char*, signed char);
-unsigned char		?^=?(         unsigned char*, unsigned char),
-    			?^=?(volatile unsigned char*, unsigned char);
-short			?^=?(         short*, short),
-    			?^=?(volatile short*, short);
-unsigned short		?^=?(         unsigned short*, unsigned short),
-    			?^=?(volatile unsigned short*, unsigned short);
-int			?^=?(         int*, int),
-    			?^=?(volatile int*, int);
-unsigned		?^=?(         unsigned*, unsigned),
-    			?^=?(volatile unsigned*, unsigned);
-long			?^=?(         long*, long),
-    			?^=?(volatile long*, long);
-unsigned long		?^=?(         unsigned long*, unsigned long),
-    			?^=?(volatile unsigned long*, unsigned long);
-long long			?^=?(         long long*, long long),
-    			?^=?(volatile long long*, long long);
-unsigned long long		?^=?(         unsigned long long*, unsigned long long),
-    			?^=?(volatile unsigned long long*, unsigned long long);
-
-
-float			?=?(         float *, float),
-    			?=?(volatile float *, float),
-    			?*=?(         float *, float),
-    			?*=?(volatile float *, float),
-    			?/=?(         float *, float),
-    			?/=?(volatile float *, float),
-    			?+=?(         float *, float),
-    			?+=?(volatile float *, float),
-    			?-=?(         float *, float),
-    			?-=?(volatile float *, float);
-
-double			?=?(         double *, double),
-    			?=?(volatile double *, double),
-    			?*=?(         double *, double),
-    			?*=?(volatile double *, double),
-    			?/=?(         double *, double),
-    			?/=?(volatile double *, double),
-    			?+=?(         double *, double),
-    			?+=?(volatile double *, double),
-    			?-=?(         double *, double),
-    			?-=?(volatile double *, double);
-
-long double		?=?(         long double *, long double),
-    			?=?(volatile long double *, long double),
-    			?*=?(         long double *, long double),
-    			?*=?(volatile long double *, long double),
-    			?/=?(         long double *, long double),
-    			?/=?(volatile long double *, long double),
-    			?+=?(         long double *, long double),
-    			?+=?(volatile long double *, long double),
-    			?-=?(         long double *, long double),
-    			?-=?(volatile long double *, long double);
-
-/*
- * ------------------------------------------------------------
- *
- * 			End of file
- *
- * ------------------------------------------------------------
- */
+forall( dtype DT ) const volatile DT *	?=?( const volatile  DT *	   *,			void * );
+forall( dtype DT ) const volatile DT *	?=?( const volatile  DT * volatile *,			void * );
+forall( dtype DT ) const volatile DT *	?=?( const volatile  DT *	   *, const		void * );
+forall( dtype DT ) const volatile DT *	?=?( const volatile  DT * volatile *, const		void * );
+forall( dtype DT ) const volatile DT *	?=?( const volatile  DT *	   *,	    volatile	void * );
+forall( dtype DT ) const volatile DT *	?=?( const volatile  DT * volatile *,	    volatile 	void * );
+forall( dtype DT ) const volatile DT *	?=?( const volatile  DT *	   *, const volatile 	void * );
+forall( dtype DT ) const volatile DT *	?=?( const volatile  DT * volatile *, const volatile 	void * );
+
+forall( dtype DT ) void *		 ?=?(		     void *	     *,			DT * );
+forall( dtype DT ) void *		 ?=?(		     void * volatile *,			DT * );
+forall( dtype DT ) const void *		 ?=?( const	     void *	     *,			DT * );
+forall( dtype DT ) const void *		 ?=?( const	     void * volatile *,			DT * );
+forall( dtype DT ) const void *		 ?=?( const	     void *	     *, const		DT * );
+forall( dtype DT ) const void *		 ?=?( const	     void * volatile *, const		DT * );
+forall( dtype DT ) volatile void *	 ?=?(	    volatile void *	     *,			DT * );
+forall( dtype DT ) volatile void *	 ?=?(	    volatile void * volatile *,			DT * );
+forall( dtype DT ) volatile void *   	 ?=?(	    volatile void *	     *,	      volatile	DT * );
+forall( dtype DT ) volatile void *   	 ?=?(	    volatile void * volatile *,	      volatile	DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void *	     *,			DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile *,			DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void *	     *, const		DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile *, const		DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void *	     *,	      volatile	DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile *,	      volatile	DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void *	     *, const volatile	DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile *, const volatile	DT * );
+
+void *			?=?(		    void *	    *,		      void * );
+void *			?=?(		    void * volatile *,		      void * );
+const void *		?=?( const	    void *	    *,		      void * );
+const void *		?=?( const	    void * volatile *,		      void * );
+const void *		?=?( const	    void *	    *, const	      void * );
+const void *		?=?( const	    void * volatile *, const	      void * );
+volatile void *		?=?(	   volatile void *	    *,		      void * );
+volatile void *		?=?(	   volatile void * volatile *,		      void * );
+volatile void *		?=?(	   volatile void *	    *,	     volatile void * );
+volatile void *		?=?(	   volatile void * volatile *,	     volatile void * );
+const volatile void *	?=?( const volatile void *	    *,		      void * );
+const volatile void *	?=?( const volatile void * volatile *,		      void * );
+const volatile void *	?=?( const volatile void *	    *, const	      void * );
+const volatile void *	?=?( const volatile void * volatile *, const	      void * );
+const volatile void *	?=?( const volatile void *	    *,	     volatile void * );
+const volatile void *	?=?( const volatile void * volatile *,	     volatile void * );
+const volatile void *	?=?( const volatile void *	    *, const volatile void * );
+const volatile void *	?=?( const volatile void * volatile *, const volatile void * );
+
+forall( dtype DT ) DT *			?=?(		    DT *	  *, forall( dtype DT2 ) const DT2 * );
+forall( dtype DT ) DT *			?=?(		    DT * volatile *, forall( dtype DT2 ) const DT2 * );
+forall( dtype DT ) const DT *		?=?( const	    DT *	  *, forall( dtype DT2 ) const DT2 * );
+forall( dtype DT ) const DT *		?=?( const	    DT * volatile *, forall( dtype DT2 ) const DT2 * );
+forall( dtype DT ) volatile DT *	?=?( volatile	    DT *	  *, forall( dtype DT2 ) const DT2 * );
+forall( dtype DT ) volatile DT *	?=?( volatile	    DT * volatile *, forall( dtype DT2 ) const DT2 * );
+forall( dtype DT ) const volatile DT *	?=?( const volatile DT *	  *, forall( dtype DT2 ) const DT2 * );
+forall( dtype DT ) const volatile DT *	?=?( const volatile DT * volatile *, forall( dtype DT2 ) const DT2 * );
+
+forall( ftype FT ) FT * 		?=?( FT *	   *, forall( ftype FT2 ) FT2 * );
+forall( ftype FT ) FT *			?=?( FT * volatile *, forall( ftype FT2 ) FT2 * );
+
+forall( type T ) T * 			?+=?(		     T *	  *, ptrdiff_t );
+forall( type T ) T *			?+=?(		     T * volatile *, ptrdiff_t );
+forall( type T ) T *			?-=?(		     T *	  *, ptrdiff_t );
+forall( type T ) T *			?-=?(		     T * volatile *, ptrdiff_t );
+forall( type T ) const T * 		?+=?( const	     T *	  *, ptrdiff_t );
+forall( type T ) const T *		?+=?( const	     T * volatile *, ptrdiff_t );
+forall( type T ) const T *		?-=?( const	     T *	  *, ptrdiff_t );
+forall( type T ) const T *		?-=?( const	     T * volatile *, ptrdiff_t );
+forall( type T ) volatile T *		?+=?(	    volatile T *	  *, ptrdiff_t );
+forall( type T ) volatile T *		?+=?(	    volatile T * volatile *, ptrdiff_t );
+forall( type T ) volatile T *		?-=?(	    volatile T *	  *, ptrdiff_t );
+forall( type T ) volatile T *		?-=?(	    volatile T * volatile *, ptrdiff_t );
+forall( type T ) const volatile T *	?+=?( const volatile T *	  *, ptrdiff_t );
+forall( type T ) const volatile T *	?+=?( const volatile T * volatile *, ptrdiff_t );
+forall( type T ) const volatile T *	?-=?( const volatile T *	  *, ptrdiff_t );
+forall( type T ) const volatile T *	?-=?( const volatile T * volatile *, ptrdiff_t );
+
+_Bool			?=?(	      _Bool *, _Bool ),
+    			?=?( volatile _Bool *, _Bool );
+char			?=?(	      char *, char ),
+    			?=?( volatile char *, char );
+signed char		?=?(	      signed char *, signed char ),
+    			?=?( volatile signed char *, signed char );
+unsigned char		?=?(	      unsigned char *, unsigned char ),
+    			?=?( volatile unsigned char *, unsigned char );
+short			?=?(	      short *, short ),
+    			?=?( volatile short *, short );
+unsigned short		?=?(	      unsigned short *, unsigned short ),
+    			?=?( volatile unsigned short *, unsigned short );
+int			?=?(	      int *, int ),
+    			?=?( volatile int *, int );
+unsigned		?=?(	      unsigned *, unsigned ),
+    			?=?( volatile unsigned *, unsigned );
+long			?=?(	      long *, long ),
+    			?=?( volatile long *, long );
+unsigned long		?=?(	      unsigned long *, unsigned long ),
+    			?=?( volatile unsigned long *, unsigned long );
+long long		?=?(	      long long *, long long ),
+    			?=?( volatile long long *, long long );
+unsigned long long	?=?(	      unsigned long long *, unsigned long long ),
+    			?=?( volatile unsigned long long *, unsigned long long );
+
+_Bool			?*=?(	       _Bool *, _Bool ),
+    			?*=?( volatile _Bool *, _Bool );
+char			?*=?(	       char *, char ),
+    			?*=?( volatile char *, char );
+signed char		?*=?(	       signed char *, signed char ),
+    			?*=?( volatile signed char *, signed char );
+unsigned char		?*=?(	       unsigned char *, unsigned char ),
+    			?*=?( volatile unsigned char *, unsigned char );
+short			?*=?(	       short *, short ),
+    			?*=?( volatile short *, short );
+unsigned short		?*=?(	       unsigned short *, unsigned short ),
+    			?*=?( volatile unsigned short *, unsigned short );
+int			?*=?(	       int *, int ),
+    			?*=?( volatile int *, int );
+unsigned		?*=?(	       unsigned *, unsigned ),
+    			?*=?( volatile unsigned *, unsigned );
+long			?*=?(	       long *, long ),
+    			?*=?( volatile long *, long );
+unsigned long		?*=?(	       unsigned long *, unsigned long ),
+    			?*=?( volatile unsigned long *, unsigned long );
+long long		?*=?(	       long long *, long long ),
+    			?*=?( volatile long long *, long long );
+unsigned long long	?*=?(	       unsigned long long *, unsigned long long ),
+    			?*=?( volatile unsigned long long *, unsigned long long );
+
+_Bool			?/=?(	       _Bool *, _Bool ),
+    			?/=?( volatile _Bool *, _Bool );
+char			?/=?(	       char *, char ),
+    			?/=?( volatile char *, char );
+signed char		?/=?(	       signed char *, signed char ),
+    			?/=?( volatile signed char *, signed char );
+unsigned char		?/=?(	       unsigned char *, unsigned char ),
+    			?/=?( volatile unsigned char *, unsigned char );
+short			?/=?(	       short *, short ),
+    			?/=?( volatile short *, short );
+unsigned short		?/=?(	       unsigned short *, unsigned short ),
+    			?/=?( volatile unsigned short *, unsigned short );
+int			?/=?(	       int *, int ),
+    			?/=?( volatile int *, int );
+unsigned		?/=?(	       unsigned *, unsigned ),
+    			?/=?( volatile unsigned *, unsigned );
+long			?/=?(	       long *, long ),
+    			?/=?( volatile long *, long );
+unsigned long		?/=?(	       unsigned long *, unsigned long ),
+    			?/=?( volatile unsigned long *, unsigned long );
+long long		?/=?(	       long long *, long long ),
+    			?/=?( volatile long long *, long long );
+unsigned long long	?/=?(	       unsigned long long *, unsigned long long ),
+    			?/=?( volatile unsigned long long *, unsigned long long );
+
+_Bool			?%=?(	       _Bool *, _Bool ),
+    			?%=?( volatile _Bool *, _Bool );
+char			?%=?(	       char *, char ),
+    			?%=?( volatile char *, char );
+signed char		?%=?(	       signed char *, signed char ),
+    			?%=?( volatile signed char *, signed char );
+unsigned char		?%=?(	       unsigned char *, unsigned char ),
+    			?%=?( volatile unsigned char *, unsigned char );
+short			?%=?(	       short *, short ),
+    			?%=?( volatile short *, short );
+unsigned short		?%=?(	       unsigned short *, unsigned short ),
+    			?%=?( volatile unsigned short *, unsigned short );
+int			?%=?(	       int *, int ),
+    			?%=?( volatile int *, int );
+unsigned		?%=?(	       unsigned *, unsigned ),
+    			?%=?( volatile unsigned *, unsigned );
+long			?%=?(	       long *, long ),
+    			?%=?( volatile long *, long );
+unsigned long		?%=?(	       unsigned long *, unsigned long ),
+    			?%=?( volatile unsigned long *, unsigned long );
+long long		?%=?(	       long long *, long long ),
+    			?%=?( volatile long long *, long long );
+unsigned long long	?%=?(	       unsigned long long *, unsigned long long ),
+    			?%=?( volatile unsigned long long *, unsigned long long );
+
+_Bool			?+=?(	       _Bool *, _Bool ),
+    			?+=?( volatile _Bool *, _Bool );
+char			?+=?(	       char *, char ),
+    			?+=?( volatile char *, char );
+signed char		?+=?(	       signed char *, signed char ),
+    			?+=?( volatile signed char *, signed char );
+unsigned char		?+=?(	       unsigned char *, unsigned char ),
+    			?+=?( volatile unsigned char *, unsigned char );
+short			?+=?(	       short *, short ),
+    			?+=?( volatile short *, short );
+unsigned short		?+=?(	       unsigned short *, unsigned short ),
+    			?+=?( volatile unsigned short *, unsigned short );
+int			?+=?(	       int *, int ),
+    			?+=?( volatile int *, int );
+unsigned		?+=?(	       unsigned *, unsigned ),
+    			?+=?( volatile unsigned *, unsigned );
+long			?+=?(	       long *, long ),
+    			?+=?( volatile long *, long );
+unsigned long		?+=?(	       unsigned long *, unsigned long ),
+    			?+=?( volatile unsigned long *, unsigned long );
+long long		?+=?(	       long long *, long long ),
+    			?+=?( volatile long long *, long long );
+unsigned long long	?+=?(	       unsigned long long *, unsigned long long ),
+    			?+=?( volatile unsigned long long *, unsigned long long );
+
+_Bool			?-=?(	       _Bool *, _Bool ),
+    			?-=?( volatile _Bool *, _Bool );
+char			?-=?(	       char *, char ),
+    			?-=?( volatile char *, char );
+signed char		?-=?(	       signed char *, signed char ),
+    			?-=?( volatile signed char *, signed char );
+unsigned char		?-=?(	       unsigned char *, unsigned char ),
+    			?-=?( volatile unsigned char *, unsigned char );
+short			?-=?(	       short *, short ),
+    			?-=?( volatile short *, short );
+unsigned short		?-=?(	       unsigned short *, unsigned short ),
+    			?-=?( volatile unsigned short *, unsigned short );
+int			?-=?(	       int *, int ),
+    			?-=?( volatile int *, int );
+unsigned		?-=?(	       unsigned *, unsigned ),
+    			?-=?( volatile unsigned *, unsigned );
+long			?-=?(	       long *, long ),
+    			?-=?( volatile long *, long );
+unsigned long		?-=?(	       unsigned long *, unsigned long ),
+    			?-=?( volatile unsigned long *, unsigned long );
+long long		?-=?(	       long long *, long long ),
+    			?-=?( volatile long long *, long long );
+unsigned long long	?-=?(	       unsigned long long *, unsigned long long ),
+    			?-=?( volatile unsigned long long *, unsigned long long );
+
+_Bool			?<<=?(	        _Bool *, _Bool ),
+    			?<<=?( volatile _Bool *, _Bool );
+char			?<<=?(	        char *, char ),
+    			?<<=?( volatile char *, char );
+signed char		?<<=?(	        signed char *, signed char ),
+    			?<<=?( volatile signed char *, signed char );
+unsigned char		?<<=?(	        unsigned char *, unsigned char ),
+    			?<<=?( volatile unsigned char *, unsigned char );
+short			?<<=?(	        short *, short ),
+    			?<<=?( volatile short *, short );
+unsigned short		?<<=?(	        unsigned short *, unsigned short ),
+    			?<<=?( volatile unsigned short *, unsigned short );
+int			?<<=?(	        int *, int ),
+    			?<<=?( volatile int *, int );
+unsigned		?<<=?(	        unsigned *, unsigned ),
+    			?<<=?( volatile unsigned *, unsigned );
+long			?<<=?(	        long *, long ),
+    			?<<=?( volatile long *, long );
+unsigned long		?<<=?(	        unsigned long *, unsigned long ),
+    			?<<=?( volatile unsigned long *, unsigned long );
+long long		?<<=?(	        long long *, long long ),
+    			?<<=?( volatile long long *, long long );
+unsigned long long	?<<=?(	        unsigned long long *, unsigned long long ),
+    			?<<=?( volatile unsigned long long *, unsigned long long );
+
+_Bool			?>>=?(	        _Bool *, _Bool ),
+    			?>>=?( volatile _Bool *, _Bool );
+char			?>>=?(	        char *, char ),
+    			?>>=?( volatile char *, char );
+signed char		?>>=?(	        signed char *, signed char ),
+    			?>>=?( volatile signed char *, signed char );
+unsigned char		?>>=?(	        unsigned char *, unsigned char ),
+    			?>>=?( volatile unsigned char *, unsigned char );
+short			?>>=?(	        short *, short ),
+    			?>>=?( volatile short *, short );
+unsigned short		?>>=?(	        unsigned short *, unsigned short ),
+    			?>>=?( volatile unsigned short *, unsigned short );
+int			?>>=?(	        int *, int ),
+    			?>>=?( volatile int *, int );
+unsigned		?>>=?(	        unsigned *, unsigned ),
+    			?>>=?( volatile unsigned *, unsigned );
+long			?>>=?(	        long *, long ),
+    			?>>=?( volatile long *, long );
+unsigned long		?>>=?(	        unsigned long *, unsigned long ),
+    			?>>=?( volatile unsigned long *, unsigned long );
+long long		?>>=?(	        long long *, long long ),
+    			?>>=?( volatile long long *, long long );
+unsigned long long	?>>=?(	        unsigned long long *, unsigned long long ),
+    			?>>=?( volatile unsigned long long *, unsigned long long );
+
+_Bool			?&=?(	       _Bool *, _Bool ),
+    			?&=?( volatile _Bool *, _Bool );
+char			?&=?(	       char *, char ),
+    			?&=?( volatile char *, char );
+signed char		?&=?(	       signed char *, signed char ),
+    			?&=?( volatile signed char *, signed char );
+unsigned char		?&=?(	       unsigned char *, unsigned char ),
+    			?&=?( volatile unsigned char *, unsigned char );
+short			?&=?(	       short *, short ),
+    			?&=?( volatile short *, short );
+unsigned short		?&=?(	       unsigned short *, unsigned short ),
+    			?&=?( volatile unsigned short *, unsigned short );
+int			?&=?(	       int *, int ),
+    			?&=?( volatile int *, int );
+unsigned		?&=?(	       unsigned *, unsigned ),
+    			?&=?( volatile unsigned *, unsigned );
+long			?&=?(	       long *, long ),
+    			?&=?( volatile long *, long );
+unsigned long		?&=?(	       unsigned long *, unsigned long ),
+    			?&=?( volatile unsigned long *, unsigned long );
+long long		?&=?(	       long long *, long long ),
+    			?&=?( volatile long long *, long long );
+unsigned long long	?&=?(	       unsigned long long *, unsigned long long ),
+    			?&=?( volatile unsigned long long *, unsigned long long );
+
+_Bool			?|=?(	       _Bool *, _Bool ),
+    			?|=?( volatile _Bool *, _Bool );
+char			?|=?(	       char *, char ),
+    			?|=?( volatile char *, char );
+signed char		?|=?(	       signed char *, signed char ),
+    			?|=?( volatile signed char *, signed char );
+unsigned char		?|=?(	       unsigned char *, unsigned char ),
+    			?|=?( volatile unsigned char *, unsigned char );
+short			?|=?(	       short *, short ),
+    			?|=?( volatile short *, short );
+unsigned short		?|=?(	       unsigned short *, unsigned short ),
+    			?|=?( volatile unsigned short *, unsigned short );
+int			?|=?(	       int *, int ),
+    			?|=?( volatile int *, int );
+unsigned		?|=?(	       unsigned *, unsigned ),
+    			?|=?( volatile unsigned *, unsigned );
+long			?|=?(	       long *, long ),
+    			?|=?( volatile long *, long );
+unsigned long		?|=?(	       unsigned long *, unsigned long ),
+    			?|=?( volatile unsigned long *, unsigned long );
+long long		?|=?(	       long long *, long long ),
+    			?|=?( volatile long long *, long long );
+unsigned long long	?|=?(	       unsigned long long *, unsigned long long ),
+    			?|=?( volatile unsigned long long *, unsigned long long );
+
+_Bool			?^=?(	       _Bool *, _Bool ),
+    			?^=?( volatile _Bool *, _Bool );
+char			?^=?(	       char *, char ),
+    			?^=?( volatile char *, char );
+signed char		?^=?(	       signed char *, signed char ),
+    			?^=?( volatile signed char *, signed char );
+unsigned char		?^=?(	       unsigned char *, unsigned char ),
+    			?^=?( volatile unsigned char *, unsigned char );
+short			?^=?(	       short *, short ),
+    			?^=?( volatile short *, short );
+unsigned short		?^=?(	       unsigned short *, unsigned short ),
+    			?^=?( volatile unsigned short *, unsigned short );
+int			?^=?(	       int *, int ),
+    			?^=?( volatile int *, int );
+unsigned		?^=?(	       unsigned *, unsigned ),
+    			?^=?( volatile unsigned *, unsigned );
+long			?^=?(	       long *, long ),
+    			?^=?( volatile long *, long );
+unsigned long		?^=?(	       unsigned long *, unsigned long ),
+    			?^=?( volatile unsigned long *, unsigned long );
+long long		?^=?(	       long long *, long long ),
+    			?^=?( volatile long long *, long long );
+unsigned long long	?^=?(	       unsigned long long *, unsigned long long ),
+    			?^=?( volatile unsigned long long *, unsigned long long );
+
+
+float			?=?(	       float *, float ),
+    			?=?(  volatile float *, float ),
+    			?*=?(	       float *, float ),
+    			?*=?( volatile float *, float ),
+    			?/=?(	       float *, float ),
+    			?/=?( volatile float *, float ),
+    			?+=?(	       float *, float ),
+    			?+=?( volatile float *, float ),
+    			?-=?(	       float *, float ),
+    			?-=?( volatile float *, float );
+
+double			?=?(	       double *, double ),
+    			?=?(  volatile double *, double ),
+    			?*=?(	       double *, double ),
+    			?*=?( volatile double *, double ),
+    			?/=?(	       double *, double ),
+    			?/=?( volatile double *, double ),
+    			?+=?(	       double *, double ),
+    			?+=?( volatile double *, double ),
+    			?-=?(	       double *, double ),
+    			?-=?( volatile double *, double );
+
+long double		?=?(	       long double *, long double ),
+    			?=?(  volatile long double *, long double ),
+    			?*=?(	       long double *, long double ),
+    			?*=?( volatile long double *, long double ),
+    			?/=?(	       long double *, long double ),
+    			?/=?( volatile long double *, long double ),
+    			?+=?(	       long double *, long double ),
+    			?+=?( volatile long double *, long double ),
+    			?-=?(	       long double *, long double ),
+    			?-=?( volatile long double *, long double );
Index: libcfa/ptrdiff_t.c
===================================================================
--- libcfa/ptrdiff_t.c	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
+++ libcfa/ptrdiff_t.c	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -0,0 +1,1 @@
+#include <stddef.h>
Index: translator/CodeGen/GenType.cc
===================================================================
--- translator/CodeGen/GenType.cc	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/CodeGen/GenType.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -64,5 +64,5 @@
   switch(basicType->get_kind()){
   case BasicType::Bool:
-    typeWords = "bool";
+    typeWords = "_Bool";
     break;
   case BasicType::Char:
Index: translator/InitTweak/BasicInit.cc
===================================================================
--- translator/InitTweak/BasicInit.cc	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/InitTweak/BasicInit.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -218,6 +218,5 @@
     args.push_back(new AddressExpr( new UntypedMemberExpr( membName, new NameExpr(toInit->get_name()) )));
     args.push_back( sinit->get_value() );
-    Statement *ret = new ExprStmt(std::list<Label>(),
-						    new UntypedExpr(new NameExpr("?=?"), args));
+    Statement *ret = new ExprStmt(std::list<Label>(), new UntypedExpr(new NameExpr("?=?"), args));
     return ret;
   }
@@ -254,6 +253,5 @@
 	args.push_back( new AddressExpr(lh) ); 	args.push_back( rh );
 
-	stmts.push_back( new ExprStmt(std::list<Label>(), 
-					       new UntypedExpr(new NameExpr("?=?"), args)) );
+	stmts.push_back( new ExprStmt(std::list<Label>(), new UntypedExpr(new NameExpr("?=?"), args)) );
       }
     }
Index: translator/Parser/DeclarationNode.cc
===================================================================
--- translator/Parser/DeclarationNode.cc	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/Parser/DeclarationNode.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -28,1025 +28,899 @@
 extern LinkageSpec::Type linkage;		/* defined in cfa.y */
 
-DeclarationNode*
-DeclarationNode::clone() const
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = maybeClone( type );
-  newnode->name = name;
-  newnode->storageClasses = storageClasses;
-  newnode->bitfieldWidth = maybeClone( bitfieldWidth );
-  newnode->hasEllipsis = hasEllipsis;
-  newnode->initializer = initializer;
-  newnode->next = maybeClone( next );
-  newnode->linkage = linkage;
-  return newnode;
-}
-
-DeclarationNode::DeclarationNode()
-  : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage )
-{
-}
-
-DeclarationNode::~DeclarationNode()
-{
-  delete type;
-  delete bitfieldWidth;
-  delete initializer;
-}
-
-bool
-DeclarationNode::get_hasEllipsis() const
-{
-  return hasEllipsis;
-}
-
-const char *storageClassName[] =
-{
-  // order must correspond with DeclarationNode::StorageClass
-  "static",
-  "auto",
-  "extern",
-  "register",
-  "inline",
-  "fortran",
+DeclarationNode *DeclarationNode::clone() const {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = maybeClone( type );
+    newnode->name = name;
+    newnode->storageClasses = storageClasses;
+    newnode->bitfieldWidth = maybeClone( bitfieldWidth );
+    newnode->hasEllipsis = hasEllipsis;
+    newnode->initializer = initializer;
+    newnode->next = maybeClone( next );
+    newnode->linkage = linkage;
+    return newnode;
+}
+
+DeclarationNode::DeclarationNode() : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage ) {
+}
+
+DeclarationNode::~DeclarationNode() {
+    delete type;
+    delete bitfieldWidth;
+    delete initializer;
+}
+
+bool DeclarationNode::get_hasEllipsis() const {
+    return hasEllipsis;
+}
+
+const char *storageClassName[] = {
+    // order must correspond with DeclarationNode::StorageClass
+    "static",
+    "auto",
+    "extern",
+    "register",
+    "inline",
+    "fortran",
 };
 
-void
-DeclarationNode::print( std::ostream &os, int indent ) const
-{
-  os << string(indent,  ' ');
-  if( name == "" ) {
+void DeclarationNode::print( std::ostream &os, int indent ) const {
+    os << string(indent, ' ' );
+    if ( name == "" ) {
 ///     os << "An unnamed ";
-  } else {
-    os << name << ": a ";
-  }
-  if( linkage != LinkageSpec::Cforall ) {
-    os << LinkageSpec::toString( linkage ) << " ";
-  }
-  printEnums( storageClasses.begin(), storageClasses.end(), storageClassName, os );
-  if( type ) {
-    type->print( os, indent );
-  } else {
-    os << "untyped entity ";
-  }
-  if( bitfieldWidth ) {
-    os << endl << string(indent+2,  ' ') << "with bitfield width ";
-    bitfieldWidth->printOneLine( os );
-  }
-
-  if( initializer != 0 ) {
-    os << endl << string(indent+2,  ' ') << "with initializer ";
-    initializer->printOneLine( os );
-  }
-
-  os << endl;
-}
-
-void
-DeclarationNode::printList( std::ostream &os, int indent ) const
-{
-  ParseNode::printList( os, indent );
-  if( hasEllipsis ) {
-    os << string( indent, ' ' )  << "and a variable number of other arguments" << endl;
-  }
-}
-
-DeclarationNode *
-DeclarationNode::newFunction( std::string* name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->name = assign_strptr( name );
-
-  newnode->type = new TypeData( TypeData::Function );
-  newnode->type->function->params = param;
-  newnode->type->function->newStyle = newStyle;
-  newnode->type->function->body = body;
-  if( body ) {
-    newnode->type->function->hasBody = true;
-  }
-
-  if( ret ) {
-    newnode->type->base = ret->type;
-    ret->type = 0;
-    delete ret;
-  }
-
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newQualifier( Qualifier q )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData();
-  newnode->type->qualifiers.push_back( q );
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newStorageClass( StorageClass sc )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->storageClasses.push_back( sc );
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newBasicType( BasicType bt )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::Basic );
-  newnode->type->basic->typeSpec.push_back( bt );
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newModifier( Modifier mod )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::Basic );
-  newnode->type->basic->modifiers.push_back( mod );
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newForall( DeclarationNode* forall )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::Unknown );
-  newnode->type->forall = forall;
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newFromTypedef( std::string* name )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::SymbolicInst );
-  newnode->type->symbolic->name = assign_strptr( name );
-  newnode->type->symbolic->isTypedef = true;
-  newnode->type->symbolic->params = 0;
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::Aggregate );
-  newnode->type->aggregate->kind = kind;
-  newnode->type->aggregate->name = assign_strptr( name );
-  if( newnode->type->aggregate->name == "" ) {
-    newnode->type->aggregate->name = DeclarationNode::anonymous.newName();
-  }
-  newnode->type->aggregate->params = formals;
-  newnode->type->aggregate->actuals = actuals;
-  newnode->type->aggregate->members = fields;
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newEnum( std::string *name, DeclarationNode *constants )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->name = assign_strptr( name );
-  newnode->type = new TypeData( TypeData::Enum );
-  newnode->type->enumeration->name = newnode->name;
-  if( newnode->type->enumeration->name == "" ) {
-    newnode->type->enumeration->name = DeclarationNode::anonymous.newName();
-  }
-  newnode->type->enumeration->constants = constants;
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newEnumConstant( std::string* name, ExpressionNode *constant )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->name = assign_strptr( name );
-  // do something with the constant
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newName( std::string* name )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->name = assign_strptr( name );
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newFromTypeGen( std::string* name, ExpressionNode *params )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::SymbolicInst );
-  newnode->type->symbolic->name = assign_strptr( name );
-  newnode->type->symbolic->isTypedef = false;
-  newnode->type->symbolic->actuals = params;
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newTypeParam( TypeClass tc, std::string* name )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->name = assign_strptr( name );
-  newnode->type = new TypeData( TypeData::Variable );
-  newnode->type->variable->tyClass = tc;
-  newnode->type->variable->name = newnode->name;
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::Aggregate );
-  newnode->type->aggregate->kind = Context;
-  newnode->type->aggregate->params = params;
-  newnode->type->aggregate->members = asserts;
-  newnode->type->aggregate->name = assign_strptr( name );
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newContextUse( std::string *name, ExpressionNode *params )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::AggregateInst );
-  newnode->type->aggInst->aggregate = new TypeData( TypeData::Aggregate );
-  newnode->type->aggInst->aggregate->aggregate->kind = Context;
-  newnode->type->aggInst->aggregate->aggregate->name = assign_strptr( name );
-  newnode->type->aggInst->params = params;
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->name = assign_strptr( name );
-  newnode->type = new TypeData( TypeData::Symbolic );
-  newnode->type->symbolic->isTypedef = false;
-  newnode->type->symbolic->params = typeParams;
-  newnode->type->symbolic->name = newnode->name;
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newPointer( DeclarationNode *qualifiers )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::Pointer );
-  return newnode->addQualifiers( qualifiers );
-}
-
-DeclarationNode *
-DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::Array );
-  newnode->type->array->dimension = size;
-  newnode->type->array->isStatic = isStatic;
-  newnode->type->array->isVarLen = false;
-  return newnode->addQualifiers( qualifiers );
-}
-
-DeclarationNode *
-DeclarationNode::newVarArray( DeclarationNode *qualifiers )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::Array );
-  newnode->type->array->dimension = 0;
-  newnode->type->array->isStatic = false;
-  newnode->type->array->isVarLen = true;
-  return newnode->addQualifiers( qualifiers );
-}
-
-DeclarationNode *
-DeclarationNode::newBitfield( ExpressionNode *size )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->bitfieldWidth = size;
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newTuple( DeclarationNode *members )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::Tuple );
-  newnode->type->tuple->members = members;
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newTypeof( ExpressionNode *expr )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::Typeof );
-  newnode->type->typeexpr->expr = expr;
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newAttr( std::string *name, ExpressionNode *expr )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::Attr );
-  newnode->type->attr->name = assign_strptr( name );
-  newnode->type->attr->expr = expr;
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::newAttr( std::string *name, DeclarationNode *type )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = new TypeData( TypeData::Attr );
-  newnode->type->attr->name = assign_strptr( name );
-  newnode->type->attr->type = type;
-  return newnode;
+    } else {
+	os << name << ": a ";
+    }
+
+    if ( linkage != LinkageSpec::Cforall ) {
+	os << LinkageSpec::toString( linkage ) << " ";
+    }
+
+    printEnums( storageClasses.begin(), storageClasses.end(), storageClassName, os );
+    if ( type ) {
+	type->print( os, indent );
+    } else {
+	os << "untyped entity ";
+    }
+
+    if ( bitfieldWidth ) {
+	os << endl << string(indent+2,  ' ') << "with bitfield width ";
+	bitfieldWidth->printOneLine( os );
+    }
+
+    if ( initializer != 0 ) {
+	os << endl << string(indent+2,  ' ') << "with initializer ";
+	initializer->printOneLine( os );
+    }
+
+    os << endl;
+}
+
+void DeclarationNode::printList( std::ostream &os, int indent ) const {
+    ParseNode::printList( os, indent );
+    if ( hasEllipsis ) {
+	os << string( indent, ' ' )  << "and a variable number of other arguments" << endl;
+    }
+}
+
+DeclarationNode *DeclarationNode::newFunction( std::string* name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->name = assign_strptr( name );
+
+    newnode->type = new TypeData( TypeData::Function );
+    newnode->type->function->params = param;
+    newnode->type->function->newStyle = newStyle;
+    newnode->type->function->body = body;
+
+    if ( body ) {
+	newnode->type->function->hasBody = true;
+    }
+
+    if ( ret ) {
+	newnode->type->base = ret->type;
+	ret->type = 0;
+	delete ret;
+    }
+
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newQualifier( Qualifier q ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData();
+    newnode->type->qualifiers.push_back( q );
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newStorageClass( StorageClass sc ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->storageClasses.push_back( sc );
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newBasicType( BasicType bt ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::Basic );
+    newnode->type->basic->typeSpec.push_back( bt );
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newModifier( Modifier mod ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::Basic );
+    newnode->type->basic->modifiers.push_back( mod );
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newForall( DeclarationNode* forall ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::Unknown );
+    newnode->type->forall = forall;
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newFromTypedef( std::string* name ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::SymbolicInst );
+    newnode->type->symbolic->name = assign_strptr( name );
+    newnode->type->symbolic->isTypedef = true;
+    newnode->type->symbolic->params = 0;
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::Aggregate );
+    newnode->type->aggregate->kind = kind;
+    newnode->type->aggregate->name = assign_strptr( name );
+    if ( newnode->type->aggregate->name == "" ) {
+	newnode->type->aggregate->name = DeclarationNode::anonymous.newName();
+    }
+    newnode->type->aggregate->params = formals;
+    newnode->type->aggregate->actuals = actuals;
+    newnode->type->aggregate->members = fields;
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->name = assign_strptr( name );
+    newnode->type = new TypeData( TypeData::Enum );
+    newnode->type->enumeration->name = newnode->name;
+    if ( newnode->type->enumeration->name == "" ) {
+	newnode->type->enumeration->name = DeclarationNode::anonymous.newName();
+    }
+    newnode->type->enumeration->constants = constants;
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newEnumConstant( std::string* name, ExpressionNode *constant ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->name = assign_strptr( name );
+    // do something with the constant
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newName( std::string* name ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->name = assign_strptr( name );
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newFromTypeGen( std::string* name, ExpressionNode *params ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::SymbolicInst );
+    newnode->type->symbolic->name = assign_strptr( name );
+    newnode->type->symbolic->isTypedef = false;
+    newnode->type->symbolic->actuals = params;
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string* name ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->name = assign_strptr( name );
+    newnode->type = new TypeData( TypeData::Variable );
+    newnode->type->variable->tyClass = tc;
+    newnode->type->variable->name = newnode->name;
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::Aggregate );
+    newnode->type->aggregate->kind = Context;
+    newnode->type->aggregate->params = params;
+    newnode->type->aggregate->members = asserts;
+    newnode->type->aggregate->name = assign_strptr( name );
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newContextUse( std::string *name, ExpressionNode *params ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::AggregateInst );
+    newnode->type->aggInst->aggregate = new TypeData( TypeData::Aggregate );
+    newnode->type->aggInst->aggregate->aggregate->kind = Context;
+    newnode->type->aggInst->aggregate->aggregate->name = assign_strptr( name );
+    newnode->type->aggInst->params = params;
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->name = assign_strptr( name );
+    newnode->type = new TypeData( TypeData::Symbolic );
+    newnode->type->symbolic->isTypedef = false;
+    newnode->type->symbolic->params = typeParams;
+    newnode->type->symbolic->name = newnode->name;
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::Pointer );
+    return newnode->addQualifiers( qualifiers );
+}
+
+DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::Array );
+    newnode->type->array->dimension = size;
+    newnode->type->array->isStatic = isStatic;
+    newnode->type->array->isVarLen = false;
+    return newnode->addQualifiers( qualifiers );
+}
+
+DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::Array );
+    newnode->type->array->dimension = 0;
+    newnode->type->array->isStatic = false;
+    newnode->type->array->isVarLen = true;
+    return newnode->addQualifiers( qualifiers );
+}
+
+DeclarationNode *DeclarationNode::newBitfield( ExpressionNode *size ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->bitfieldWidth = size;
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newTuple( DeclarationNode *members ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::Tuple );
+    newnode->type->tuple->members = members;
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newTypeof( ExpressionNode *expr ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::Typeof );
+    newnode->type->typeexpr->expr = expr;
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newAttr( std::string *name, ExpressionNode *expr ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::Attr );
+    newnode->type->attr->name = assign_strptr( name );
+    newnode->type->attr->expr = expr;
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::newAttr( std::string *name, DeclarationNode *type ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = new TypeData( TypeData::Attr );
+    newnode->type->attr->name = assign_strptr( name );
+    newnode->type->attr->type = type;
+    return newnode;
+}
+
+static void addQualifiersToType( TypeData *&src, TypeData *dst ) {
+    if ( src && dst ) {
+	if ( src->forall && dst->kind == TypeData::Function ) {
+	    if ( dst->forall ) {
+		dst->forall->appendList( src->forall );
+	    } else {
+		dst->forall = src->forall;
+	    }
+	    src->forall = 0;
+	}
+	if ( dst->base ) {
+	    addQualifiersToType( src, dst->base );
+	} else if ( dst->kind == TypeData::Function ) {
+	    dst->base = src;
+	    src = 0;
+	} else {
+	    dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
+	}
+    }
+}
+      
+DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
+    if ( q ) {
+	storageClasses.splice( storageClasses.end(), q->storageClasses );
+	if ( q->type ) {
+	    if ( ! type ) {
+		type = new TypeData;
+	    }
+	    addQualifiersToType( q->type, type );
+	    if ( q->type && q->type->forall ) {
+		if ( type->forall ) {
+		    type->forall->appendList( q->type->forall );
+		} else {
+		    type->forall = q->type->forall;
+		}
+		q->type->forall = 0;
+	    }
+	}
+    }
+    delete q;
+    return this;
+}
+
+DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
+    storageClasses = q->storageClasses;
+    return this;
+}
+
+static void addTypeToType( TypeData *&src, TypeData *&dst ) {
+    if ( src && dst ) {
+	if ( src->forall && dst->kind == TypeData::Function ) {
+	    if ( dst->forall ) {
+		dst->forall->appendList( src->forall );
+	    } else {
+		dst->forall = src->forall;
+	    }
+	    src->forall = 0;
+	}
+	if ( dst->base ) {
+	    addTypeToType( src, dst->base );
+	} else {
+	    switch ( dst->kind ) {
+	      case TypeData::Unknown:
+		src->qualifiers.splice( src->qualifiers.end(), dst->qualifiers );
+		dst = src;
+		src = 0;
+		break;
+
+	      case TypeData::Basic:
+		dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
+		if ( src->kind != TypeData::Unknown ) {
+		    assert( src->kind == TypeData::Basic );
+		    dst->basic->modifiers.splice( dst->basic->modifiers.end(), src->basic->modifiers );
+		    dst->basic->typeSpec.splice( dst->basic->typeSpec.end(), src->basic->typeSpec );
+		}
+		break;
+
+	      default:
+		switch ( src->kind ) {
+		  case TypeData::Aggregate:
+		  case TypeData::Enum:
+		    dst->base = new TypeData( TypeData::AggregateInst );
+		    dst->base->aggInst->aggregate = src;
+		    if ( src->kind == TypeData::Aggregate ) {
+			dst->base->aggInst->params = maybeClone( src->aggregate->actuals );
+		    }
+		    dst->base->qualifiers.splice( dst->base->qualifiers.end(), src->qualifiers );
+		    src = 0;
+		    break;
+          
+		  default:
+		    if ( dst->forall ) {
+			dst->forall->appendList( src->forall );
+		    } else {
+			dst->forall = src->forall;
+		    }
+		    src->forall = 0;
+		    dst->base = src;
+		    src = 0;
+		}
+	    }
+	}
+    }
+}
+
+DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
+    if ( o ) {
+	storageClasses.splice( storageClasses.end(), o->storageClasses );
+	if ( o->type ) {
+	    if ( ! type ) {
+		if ( o->type->kind == TypeData::Aggregate || o->type->kind == TypeData::Enum ) {
+		    type = new TypeData( TypeData::AggregateInst );
+		    type->aggInst->aggregate = o->type;
+		    if ( o->type->kind == TypeData::Aggregate ) {
+			type->aggInst->params = maybeClone( o->type->aggregate->actuals );
+		    }
+		    type->qualifiers.splice( type->qualifiers.end(), o->type->qualifiers );
+		} else {
+		    type = o->type;
+		}
+		o->type = 0;
+	    } else {
+		addTypeToType( o->type, type );
+	    }
+	}
+	if ( o->bitfieldWidth ) {
+	    bitfieldWidth = o->bitfieldWidth;
+	}
+    }
+    delete o;
+    return this;
+}
+
+DeclarationNode *DeclarationNode::addTypedef() {
+    TypeData *newtype = new TypeData( TypeData::Symbolic );
+    newtype->symbolic->params = 0;
+    newtype->symbolic->isTypedef = true;
+    newtype->symbolic->name = name;
+    newtype->base = type;
+    type = newtype;
+    return this;
+}
+
+DeclarationNode *DeclarationNode::addAssertions( DeclarationNode* assertions ) {
+    assert( type );
+    switch ( type->kind ) {
+      case TypeData::Symbolic:
+	if ( type->symbolic->assertions ) {
+	    type->symbolic->assertions->appendList( assertions );
+	} else {
+	    type->symbolic->assertions = assertions;
+	}
+	break;
+    
+      case TypeData::Variable:
+	if ( type->variable->assertions ) {
+	    type->variable->assertions->appendList( assertions );
+	} else {
+	    type->variable->assertions = assertions;
+	}
+	break;
+    
+      default:
+	assert( false );
+    }
+    
+    return this;
+}
+
+DeclarationNode *DeclarationNode::addName( std::string* newname ) {
+    name = assign_strptr( newname );
+    return this;
+}
+
+DeclarationNode *DeclarationNode::addBitfield( ExpressionNode *size ) {
+    bitfieldWidth = size;
+    return this;
+}
+
+DeclarationNode *DeclarationNode::addVarArgs() {
+    assert( type );
+    hasEllipsis = true;
+    return this;
+}
+
+DeclarationNode *DeclarationNode::addFunctionBody( StatementNode *body ) {
+    assert( type );
+    assert( type->kind == TypeData::Function );
+    assert( type->function->body == 0 );
+    type->function->body = body;
+    type->function->hasBody = true;
+    return this;
+}
+
+DeclarationNode *DeclarationNode::addOldDeclList( DeclarationNode *list ) {
+    assert( type );
+    assert( type->kind == TypeData::Function );
+    assert( type->function->oldDeclList == 0 );
+    type->function->oldDeclList = list;
+    return this;
 }
 
 static void
-addQualifiersToType( TypeData *&src, TypeData *dst )
-{
-  if( src && dst ) {
-    if( src->forall && dst->kind == TypeData::Function ) {
-      if( dst->forall ) {
-	dst->forall->appendList( src->forall );
-      } else {
-	dst->forall = src->forall;
-      }
-      src->forall = 0;
-    }
-    if( dst->base ) {
-      addQualifiersToType( src, dst->base );
-    } else if( dst->kind == TypeData::Function ) {
-      dst->base = src;
-      src = 0;
+setBase( TypeData *&type, TypeData *newType ) {
+    if ( type ) {
+	TypeData *prevBase = type;
+	TypeData *curBase = type->base;
+	while( curBase != 0 ) {
+	    prevBase = curBase;
+	    curBase = curBase->base;
+	}
+	prevBase->base = newType;
     } else {
-      dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
-    }
-  }
-}
-      
-DeclarationNode *
-DeclarationNode::addQualifiers( DeclarationNode *q )
-{
-  if( q ) {
-    storageClasses.splice( storageClasses.end(), q->storageClasses );
-    if( q->type ) {
-      if( !type ) {
-	type = new TypeData;
-      }
-      addQualifiersToType( q->type, type );
-      if( q->type && q->type->forall ) {
-        if( type->forall ) {
-          type->forall->appendList( q->type->forall );
-        } else {
-          type->forall = q->type->forall;
-        }
-        q->type->forall = 0;
-      }
-    }
-  }
-  delete q;
-  return this;
-}
-
-DeclarationNode *
-DeclarationNode::copyStorageClasses( DeclarationNode *q )
-{
-  storageClasses = q->storageClasses;
-  return this;
-}
-
-static void
-addTypeToType( TypeData *&src, TypeData *&dst )
-{
-  if( src && dst ) {
-    if( src->forall && dst->kind == TypeData::Function ) {
-      if( dst->forall ) {
-        dst->forall->appendList( src->forall );
-      } else {
-        dst->forall = src->forall;
-      }
-      src->forall = 0;
-    }
-    if( dst->base ) {
-      addTypeToType( src, dst->base );
+	type = newType;
+    }
+}
+
+DeclarationNode *DeclarationNode::addPointer( DeclarationNode *p ) {
+    if ( p ) {
+	assert( p->type->kind == TypeData::Pointer );
+	setBase( type, p->type );
+	p->type = 0;
+	delete p;
+    }
+    return this;
+}
+
+DeclarationNode *DeclarationNode::addArray( DeclarationNode *a ) {
+    if ( a ) {
+	assert( a->type->kind == TypeData::Array );
+	setBase( type, a->type );
+	a->type = 0;
+	delete a;
+    }
+    return this;
+}
+
+DeclarationNode *DeclarationNode::addNewPointer( DeclarationNode *p ) {
+    if ( p ) {
+	assert( p->type->kind == TypeData::Pointer );
+	if ( type ) {
+	    switch ( type->kind ) {
+	      case TypeData::Aggregate:
+	      case TypeData::Enum:
+		p->type->base = new TypeData( TypeData::AggregateInst );
+		p->type->base->aggInst->aggregate = type;
+		if ( type->kind == TypeData::Aggregate ) {
+		    p->type->base->aggInst->params = maybeClone( type->aggregate->actuals );
+		}
+		p->type->base->qualifiers.splice( p->type->base->qualifiers.end(), type->qualifiers );
+		break;
+        
+	      default:
+		p->type->base = type;
+	    }
+	    type = 0;
+	}
+	delete this;
+	return p;
     } else {
-      switch( dst->kind ) {
-      case TypeData::Unknown:
-	src->qualifiers.splice( src->qualifiers.end(), dst->qualifiers );
-	dst = src;
-	src = 0;
-	break;
-
-      case TypeData::Basic:
-	dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
-        if( src->kind != TypeData::Unknown ) {
-	  assert( src->kind == TypeData::Basic );
-	  dst->basic->modifiers.splice( dst->basic->modifiers.end(), src->basic->modifiers );
-	  dst->basic->typeSpec.splice( dst->basic->typeSpec.end(), src->basic->typeSpec );
-	}
-	break;
-
-      default:
-        switch( src->kind ) {
-        case TypeData::Aggregate:
-        case TypeData::Enum:
-          dst->base = new TypeData( TypeData::AggregateInst );
-          dst->base->aggInst->aggregate = src;
-          if( src->kind == TypeData::Aggregate ) {
-            dst->base->aggInst->params = maybeClone( src->aggregate->actuals );
-          }
-          dst->base->qualifiers.splice( dst->base->qualifiers.end(), src->qualifiers );
-          src = 0;
-          break;
-          
-        default:
-          if( dst->forall ) {
-            dst->forall->appendList( src->forall );
-          } else {
-            dst->forall = src->forall;
-          }
-          src->forall = 0;
-          dst->base = src;
-          src = 0;
-        }
-      }
-    }
-  }
-}
-
-DeclarationNode *
-DeclarationNode::addType( DeclarationNode *o )
-{
-  if( o ) {
-    storageClasses.splice( storageClasses.end(), o->storageClasses );
-    if ( o->type ) {
-      if( !type ) {
-        if( o->type->kind == TypeData::Aggregate || o->type->kind == TypeData::Enum ) {
-	  type = new TypeData( TypeData::AggregateInst );
-	  type->aggInst->aggregate = o->type;
-	  if( o->type->kind == TypeData::Aggregate ) {
-	    type->aggInst->params = maybeClone( o->type->aggregate->actuals );
-          }
-          type->qualifiers.splice( type->qualifiers.end(), o->type->qualifiers );
+	return this;
+    }
+}
+
+static TypeData *findLast( TypeData *a ) {
+    assert( a );
+    TypeData *cur = a;
+    while( cur->base ) {
+	cur = cur->base;
+    }
+    return cur;
+}
+
+DeclarationNode *DeclarationNode::addNewArray( DeclarationNode *a ) {
+    if ( a ) {
+	assert( a->type->kind == TypeData::Array );
+	TypeData *lastArray = findLast( a->type );
+	if ( type ) {  
+	    switch ( type->kind ) {
+	      case TypeData::Aggregate:
+	      case TypeData::Enum:
+		lastArray->base = new TypeData( TypeData::AggregateInst );
+		lastArray->base->aggInst->aggregate = type;
+		if ( type->kind == TypeData::Aggregate ) {
+		    lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals );
+		}
+		lastArray->base->qualifiers.splice( lastArray->base->qualifiers.end(), type->qualifiers );
+		break;
+        
+	      default:
+		lastArray->base = type;
+	    }
+	    type = 0;
+	}
+	delete this;
+	return a;
+    } else {
+	return this;
+    }
+}
+
+DeclarationNode *DeclarationNode::addParamList( DeclarationNode *params ) {
+    TypeData *ftype = new TypeData( TypeData::Function );
+    ftype->function->params = params;
+    setBase( type, ftype );
+    return this;
+}
+
+static TypeData *addIdListToType( TypeData *type, DeclarationNode *ids ) {
+    if ( type ) {
+	if ( type->kind != TypeData::Function ) {
+	    type->base = addIdListToType( type->base, ids );
 	} else {
-	  type = o->type;
-	}
-	o->type = 0;
-      } else {
-	addTypeToType( o->type, type );
-      }
-    }
-    if( o->bitfieldWidth ) {
-      bitfieldWidth = o->bitfieldWidth;
-    }
-  }
-  delete o;
-  return this;
-}
-
-DeclarationNode *
-DeclarationNode::addTypedef()
-{
-  TypeData *newtype = new TypeData( TypeData::Symbolic );
-  newtype->symbolic->params = 0;
-  newtype->symbolic->isTypedef = true;
-  newtype->symbolic->name = name;
-  newtype->base = type;
-  type = newtype;
-  return this;
-}
-
-DeclarationNode *
-DeclarationNode::addAssertions( DeclarationNode* assertions )
-{
-  assert( type );
-  switch( type->kind ) {
-  case TypeData::Symbolic:
-    if( type->symbolic->assertions ) {
-      type->symbolic->assertions->appendList( assertions );
+	    type->function->idList = ids;
+	}
+	return type;
     } else {
-      type->symbolic->assertions = assertions;
-    }
-    break;
+	TypeData *newtype = new TypeData( TypeData::Function );
+	newtype->function->idList = ids;
+	return newtype;
+    }
+}
     
-  case TypeData::Variable:
-    if( type->variable->assertions ) {
-      type->variable->assertions->appendList( assertions );
+DeclarationNode *DeclarationNode::addIdList( DeclarationNode *ids ) {
+    type = addIdListToType( type, ids );
+    return this;
+}
+
+DeclarationNode *DeclarationNode::addInitializer( InitializerNode *init ) {
+    //assert
+    initializer = init;
+    return this;
+}
+
+DeclarationNode *DeclarationNode::cloneBaseType( string *newName ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    TypeData *srcType = type;
+    while( srcType->base ) {
+	srcType = srcType->base;
+    }
+    newnode->type = maybeClone( srcType );
+    if ( newnode->type->kind == TypeData::AggregateInst ) {
+	// don't duplicate members
+	if ( newnode->type->aggInst->aggregate->kind == TypeData::Enum ) {
+	    delete newnode->type->aggInst->aggregate->enumeration->constants;
+	    newnode->type->aggInst->aggregate->enumeration->constants = 0;
+	} else {
+	    assert( newnode->type->aggInst->aggregate->kind == TypeData::Aggregate );
+	    delete newnode->type->aggInst->aggregate->aggregate->members;
+	    newnode->type->aggInst->aggregate->aggregate->members = 0;
+	}
+    }
+    newnode->type->forall = maybeClone( type->forall );
+    newnode->storageClasses = storageClasses;
+    newnode->name = assign_strptr( newName );
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) {
+    if ( o ) {
+	o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
+	if ( type ) {
+	    TypeData *srcType = type;
+	    while( srcType->base ) {
+		srcType = srcType->base;
+	    }
+	    TypeData *newType = srcType->clone();
+	    if ( newType->kind == TypeData::AggregateInst ) {
+		// don't duplicate members
+		if ( newType->aggInst->aggregate->kind == TypeData::Enum ) {
+		    delete newType->aggInst->aggregate->enumeration->constants;
+		    newType->aggInst->aggregate->enumeration->constants = 0;
+		} else {
+		    assert( newType->aggInst->aggregate->kind == TypeData::Aggregate );
+		    delete newType->aggInst->aggregate->aggregate->members;
+		    newType->aggInst->aggregate->aggregate->members = 0;
+		}
+	    }
+	    newType->forall = maybeClone( type->forall );
+	    if ( ! o->type ) {
+		o->type = newType;
+	    } else {
+		addTypeToType( newType, o->type );
+		delete newType;
+	    }
+	}
+    }
+    return o;
+}
+
+DeclarationNode *DeclarationNode::cloneType( string *newName ) {
+    DeclarationNode *newnode = new DeclarationNode;
+    newnode->type = maybeClone( type );
+    newnode->storageClasses = storageClasses;
+    newnode->name = assign_strptr( newName );
+    return newnode;
+}
+
+DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
+    if ( o ) {
+	o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
+	if ( type ) {
+	    TypeData *newType = type->clone();
+	    if ( ! o->type ) {
+		o->type = newType;
+	    } else {
+		addTypeToType( newType, o->type );
+		delete newType;
+	    }
+	}
+    }
+    return o;
+}
+
+DeclarationNode *DeclarationNode::appendList( DeclarationNode *node ) {
+    if ( node != 0 ) {
+	set_link( node );
+    }
+    return this;
+}
+
+DeclarationNode *DeclarationNode::extractAggregate() const {
+    if ( type ) {
+	TypeData *ret = type->extractAggregate();
+	if ( ret ) {
+	    DeclarationNode *newnode = new DeclarationNode;
+	    newnode->type = ret;
+	    return newnode;
+	} else {
+	    return 0;
+	}
     } else {
-      type->variable->assertions = assertions;
-    }
-    break;
-    
-  default:
-    assert( false );
-  }
-    
-  return this;
-}
-
-DeclarationNode *
-DeclarationNode::addName( std::string* newname )
-{
-  name = assign_strptr( newname );
-  return this;
-}
-
-DeclarationNode *
-DeclarationNode::addBitfield( ExpressionNode *size )
-{
-  bitfieldWidth = size;
-  return this;
-}
-
-DeclarationNode *
-DeclarationNode::addVarArgs()
-{
-  assert( type );
-  hasEllipsis = true;
-  return this;
-}
-
-DeclarationNode *
-DeclarationNode::addFunctionBody( StatementNode *body )
-{
-  assert( type );
-  assert( type->kind == TypeData::Function );
-  assert( type->function->body == 0 );
-  type->function->body = body;
-  type->function->hasBody = true;
-  return this;
-}
-
-DeclarationNode *
-DeclarationNode::addOldDeclList( DeclarationNode *list )
-{
-  assert( type );
-  assert( type->kind == TypeData::Function );
-  assert( type->function->oldDeclList == 0 );
-  type->function->oldDeclList = list;
-  return this;
-}
-
-static void
-setBase( TypeData *&type, TypeData *newType )
-{
-  if( type ) {
-    TypeData *prevBase = type;
-    TypeData *curBase = type->base;
-    while( curBase != 0 ) {
-      prevBase = curBase;
-      curBase = curBase->base;
-    }
-    prevBase->base = newType;
-  } else {
-    type = newType;
-  }
-}
-
-DeclarationNode *
-DeclarationNode::addPointer( DeclarationNode *p )
-{
-  if( p ) {
-    assert( p->type->kind == TypeData::Pointer );
-    setBase( type, p->type );
-    p->type = 0;
-    delete p;
-  }
-  return this;
-}
-
-DeclarationNode *
-DeclarationNode::addArray( DeclarationNode *a )
-{
-  if( a ) {
-    assert( a->type->kind == TypeData::Array );
-    setBase( type, a->type );
-    a->type = 0;
-    delete a;
-  }
-  return this;
-}
-
-DeclarationNode *
-DeclarationNode::addNewPointer( DeclarationNode *p )
-{
-  if( p ) {
-    assert( p->type->kind == TypeData::Pointer );
-    if( type ) {
-      switch( type->kind ) {
-      case TypeData::Aggregate:
-      case TypeData::Enum:
-        p->type->base = new TypeData( TypeData::AggregateInst );
-        p->type->base->aggInst->aggregate = type;
-       	if( type->kind == TypeData::Aggregate ) {
-       	  p->type->base->aggInst->params = maybeClone( type->aggregate->actuals );
-       	}
-        p->type->base->qualifiers.splice( p->type->base->qualifiers.end(), type->qualifiers );
-        break;
-        
-      default:
-        p->type->base = type;
-      }
-      type = 0;
-    }
-    delete this;
-    return p;
-  } else {
-    return this;
-  }
-}
-
-static TypeData *
-findLast( TypeData *a )
-{
-  assert( a );
-  TypeData *cur = a;
-  while( cur->base ) {
-    cur = cur->base;
-  }
-  return cur;
-}
-
-DeclarationNode *
-DeclarationNode::addNewArray( DeclarationNode *a )
-{
-  if( a ) {
-    assert( a->type->kind == TypeData::Array );
-    TypeData *lastArray = findLast( a->type );
-    if( type ) {  
-      switch( type->kind ) {
-      case TypeData::Aggregate:
-      case TypeData::Enum:
-        lastArray->base = new TypeData( TypeData::AggregateInst );
-        lastArray->base->aggInst->aggregate = type;
-        if( type->kind == TypeData::Aggregate ) {
-          lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals );
-        }
-        lastArray->base->qualifiers.splice( lastArray->base->qualifiers.end(), type->qualifiers );
-        break;
-        
-      default:
-        lastArray->base = type;
-      }
-      type = 0;
-    }
-    delete this;
-    return a;
-  } else {
-    return this;
-  }
-}
-
-DeclarationNode *
-DeclarationNode::addParamList( DeclarationNode *params )
-{
-  TypeData *ftype = new TypeData( TypeData::Function );
-  ftype->function->params = params;
-  setBase( type, ftype );
-  return this;
-}
-
-static TypeData*
-addIdListToType( TypeData *type, DeclarationNode *ids )
-{
-  if( type ) {
-    if( type->kind != TypeData::Function ) {
-      type->base = addIdListToType( type->base, ids );
-    } else {
-      type->function->idList = ids;
-    }
-    return type;
-  } else {
-    TypeData *newtype = new TypeData( TypeData::Function );
-    newtype->function->idList = ids;
-    return newtype;
-  }
-}
-    
-DeclarationNode *
-DeclarationNode::addIdList( DeclarationNode *ids )
-{
-  type = addIdListToType( type, ids );
-  return this;
-}
-
-DeclarationNode *
-DeclarationNode::addInitializer( InitializerNode *init )
-{
-  //assert
-  initializer = init;
-  return this;
-}
-
-DeclarationNode *
-DeclarationNode::cloneBaseType( string *newName )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  TypeData *srcType = type;
-  while( srcType->base ) {
-    srcType = srcType->base;
-  }
-  newnode->type = maybeClone( srcType );
-  if( newnode->type->kind == TypeData::AggregateInst ) {
-    // don't duplicate members
-    if( newnode->type->aggInst->aggregate->kind == TypeData::Enum ) {
-      delete newnode->type->aggInst->aggregate->enumeration->constants;
-      newnode->type->aggInst->aggregate->enumeration->constants = 0;
-    } else {
-      assert( newnode->type->aggInst->aggregate->kind == TypeData::Aggregate );
-      delete newnode->type->aggInst->aggregate->aggregate->members;
-      newnode->type->aggInst->aggregate->aggregate->members = 0;
-    }
-  }
-  newnode->type->forall = maybeClone( type->forall );
-  newnode->storageClasses = storageClasses;
-  newnode->name = assign_strptr( newName );
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::cloneBaseType( DeclarationNode *o )
-{
-  if( o ) {
-    o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
-    if ( type ) {
-      TypeData *srcType = type;
-      while( srcType->base ) {
-	srcType = srcType->base;
-      }
-      TypeData *newType = srcType->clone();
-      if( newType->kind == TypeData::AggregateInst ) {
-        // don't duplicate members
-        if( newType->aggInst->aggregate->kind == TypeData::Enum ) {
-          delete newType->aggInst->aggregate->enumeration->constants;
-          newType->aggInst->aggregate->enumeration->constants = 0;
-        } else {
-          assert( newType->aggInst->aggregate->kind == TypeData::Aggregate );
-          delete newType->aggInst->aggregate->aggregate->members;
-          newType->aggInst->aggregate->aggregate->members = 0;
-        }
-      }
-      newType->forall = maybeClone( type->forall );
-      if( !o->type ) {
-	o->type = newType;
-      } else {
-	addTypeToType( newType, o->type );
-	delete newType;
-      }
-    }
-  }
-  return o;
-}
-
-DeclarationNode *
-DeclarationNode::cloneType( string *newName )
-{
-  DeclarationNode *newnode = new DeclarationNode;
-  newnode->type = maybeClone( type );
-  newnode->storageClasses = storageClasses;
-  newnode->name = assign_strptr( newName );
-  return newnode;
-}
-
-DeclarationNode *
-DeclarationNode::cloneType( DeclarationNode *o )
-{
-  if( o ) {
-    o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
-    if ( type ) {
-      TypeData *newType = type->clone();
-      if( !o->type ) {
-	o->type = newType;
-      } else {
-	addTypeToType( newType, o->type );
-	delete newType;
-      }
-    }
-  }
-  return o;
-}
-
-DeclarationNode *
-DeclarationNode::appendList( DeclarationNode *node )
-{
-  if( node != 0 ) {
-    set_link( node );
-  }
-  return this;
-}
-
-DeclarationNode*
-DeclarationNode::extractAggregate() const
-{
-  if( type ) {
-    TypeData *ret = type->extractAggregate();
-    if( ret ) {
-      DeclarationNode *newnode = new DeclarationNode;
-      newnode->type = ret;
-      return newnode;
-    } else {
-      return 0;
-    }
-  } else {
-    return 0;
-  }
-}
-
-void buildList( const DeclarationNode *firstNode, std::list< Declaration* > &outputList )
-{
-  SemanticError errors;
-  std::back_insert_iterator< std::list< Declaration* > > out( outputList );
-  const DeclarationNode *cur = firstNode;
-  while( cur ) {
-    try {
-      if( DeclarationNode *extr = cur->extractAggregate() ) {
-	// handle the case where a structure declaration is contained within an object or type
-	// declaration
-	Declaration *decl = extr->build();
-	if( decl ) {
-	  *out++ = decl;
-	}
-      }
-      Declaration *decl = cur->build();
-      if( decl ) {
-        *out++ = decl;
-      }
-    } catch( SemanticError &e ) {
-      errors.append( e );
-    }
-    cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
-  }
-  if( !errors.isEmpty() ) {
-    throw errors;
-  }
-}
-
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType* > &outputList )
-{
-  SemanticError errors;
-  std::back_insert_iterator< std::list< DeclarationWithType* > > out( outputList );
-  const DeclarationNode *cur = firstNode;
-  while( cur ) {
-    try {
-///       if( DeclarationNode *extr = cur->extractAggregate() ) {
+	return 0;
+    }
+}
+
+void buildList( const DeclarationNode *firstNode, std::list< Declaration* > &outputList ) {
+    SemanticError errors;
+    std::back_insert_iterator< std::list< Declaration* > > out( outputList );
+    const DeclarationNode *cur = firstNode;
+    while( cur ) {
+	try {
+	    if ( DeclarationNode *extr = cur->extractAggregate() ) {
+		// handle the case where a structure declaration is contained within an object or type
+		// declaration
+		Declaration *decl = extr->build();
+		if ( decl ) {
+		   *out++ = decl;
+		}
+	    }
+	    Declaration *decl = cur->build();
+	    if ( decl ) {
+		*out++ = decl;
+	    }
+	} catch( SemanticError &e ) {
+	    errors.append( e );
+	}
+	cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
+    }
+    if ( ! errors.isEmpty() ) {
+	throw errors;
+    }
+}
+
+void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType* > &outputList ) {
+    SemanticError errors;
+    std::back_insert_iterator< std::list< DeclarationWithType* > > out( outputList );
+    const DeclarationNode *cur = firstNode;
+    while( cur ) {
+	try {
+///       if ( DeclarationNode *extr = cur->extractAggregate() ) {
 /// 	// handle the case where a structure declaration is contained within an object or type
 /// 	// declaration
 /// 	Declaration *decl = extr->build();
-/// 	if( decl ) {
-///           *out++ = decl;
+/// 	if ( decl ) {
+///          *out++ = decl;
 /// 	}
 ///       }
-      Declaration *decl = cur->build();
-      if( decl ) {
-        if( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) {
-          *out++ = dwt;
-        } else if( StructDecl *agg = dynamic_cast< StructDecl* >( decl ) ) {
-          StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
-          *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
-          delete agg;
-        } else if( UnionDecl *agg = dynamic_cast< UnionDecl* >( decl ) ) {
-          UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
-          *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
-        }
+	    Declaration *decl = cur->build();
+	    if ( decl ) {
+		if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) {
+		   *out++ = dwt;
+		} else if ( StructDecl *agg = dynamic_cast< StructDecl* >( decl ) ) {
+		    StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
+		   *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
+		    delete agg;
+		} else if ( UnionDecl *agg = dynamic_cast< UnionDecl* >( decl ) ) {
+		    UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
+		   *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
+		}
+	    }
+	} catch( SemanticError &e ) {
+	    errors.append( e );
+	}
+	cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
+    }
+    if ( ! errors.isEmpty() ) {
+	throw errors;
+    }
+}
+
+void buildTypeList( const DeclarationNode *firstNode, std::list< Type* > &outputList ) {
+    SemanticError errors;
+    std::back_insert_iterator< std::list< Type* > > out( outputList );
+    const DeclarationNode *cur = firstNode;
+    while( cur ) {
+	try {
+	   *out++ = cur->buildType();
+	} catch( SemanticError &e ) {
+	    errors.append( e );
+	}
+	cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
+    }
+    if ( ! errors.isEmpty() ) {
+	throw errors;
+    }
+}
+
+Declaration *DeclarationNode::build() const {
+
+    if ( ! type ) {
+	if ( buildInline() ) {
+	    throw SemanticError( "invalid inline specification in declaration of ", this );
+	} else {
+	    return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) );
+	}
+    } else {
+	Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildInline(), linkage, maybeBuild< Initializer >(initializer) );
+	return newDecl;
+    }
+    // we should never get here
+    assert( false );
+    return 0;
+}
+
+Type *DeclarationNode::buildType() const {
+    assert( type );
+  
+    switch ( type->kind ) {
+      case TypeData::Enum:
+	return new EnumInstType( type->buildQualifiers(), type->enumeration->name );
+      case TypeData::Aggregate: {
+	  ReferenceToType *ret;
+	  switch ( type->aggregate->kind ) {
+	    case DeclarationNode::Struct:
+	      ret = new StructInstType( type->buildQualifiers(), type->aggregate->name );
+	      break;
+
+	    case DeclarationNode::Union:
+	      ret = new UnionInstType( type->buildQualifiers(), type->aggregate->name );
+	      break;
+
+	    case DeclarationNode::Context:
+	      ret = new ContextInstType( type->buildQualifiers(), type->aggregate->name );
+	      break;
+
+	    default:
+	      assert( false );
+	  }
+	  buildList( type->aggregate->actuals, ret->get_parameters() );
+	  return ret;
       }
-    } catch( SemanticError &e ) {
-      errors.append( e );
-    }
-    cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
-  }
-  if( !errors.isEmpty() ) {
-    throw errors;
-  }
-}
-
-void buildTypeList( const DeclarationNode *firstNode, std::list< Type* > &outputList )
-{
-  SemanticError errors;
-  std::back_insert_iterator< std::list< Type* > > out( outputList );
-  const DeclarationNode *cur = firstNode;
-  while( cur ) {
-    try {
-      *out++ = cur->buildType();
-    } catch( SemanticError &e ) {
-      errors.append( e );
-    }
-    cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
-  }
-  if( !errors.isEmpty() ) {
-    throw errors;
-  }
-}
-
-Declaration *
-DeclarationNode::build() const
-{
-
-  if( !type ) {
-    if( buildInline() ) {
-      throw SemanticError( "invalid inline specification in declaration of ", this );
+      case TypeData::Symbolic: {
+	  TypeInstType *ret = new TypeInstType( type->buildQualifiers(), type->symbolic->name, false );
+	  buildList( type->symbolic->actuals, ret->get_parameters() );
+	  return ret;
+      }
+      default:
+	return type->build();
+    }
+}
+
+Declaration::StorageClass DeclarationNode::buildStorageClass() const {
+    static const Declaration::StorageClass scMap[] = {  
+	Declaration::Static,
+	Declaration::Auto,
+	Declaration::Extern,
+	Declaration::Register,
+	Declaration::NoStorageClass, // inline
+	Declaration::Fortran
+    };  
+  
+    Declaration::StorageClass ret = Declaration::NoStorageClass;
+    for ( std::list< StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
+	assert( unsigned( *i ) < sizeof( scMap ) / sizeof( scMap[0] ) );
+	if ( *i == Inline ) continue;
+	if ( ret == Declaration::NoStorageClass ) {
+	    ret = scMap[ *i ];
+	} else {
+	    throw SemanticError( "invalid combination of storage classes in declaration of ", this );
+	}
+    }
+    return ret;
+}
+
+bool DeclarationNode::buildInline() const {
+    std::list< StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), Inline );
+    if ( first == storageClasses.end() ) {
+	return false;
     } else {
-      return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) );
-    }
-  } else {
-    Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildInline(), linkage, maybeBuild< Initializer >(initializer) );
-    return newDecl;
-  }
-  // we should never get here
-  assert( false );
-  return 0;
-}
-
-Type *
-DeclarationNode::buildType() const
-{
-
-  assert( type );
-  
-  switch( type->kind ) {
-  case TypeData::Enum:
-    return new EnumInstType( type->buildQualifiers(), type->enumeration->name );
-    
-  case TypeData::Aggregate: {
-    ReferenceToType *ret;
-    switch( type->aggregate->kind ) {
-    case DeclarationNode::Struct:
-      ret = new StructInstType( type->buildQualifiers(), type->aggregate->name );
-      break;
-
-    case DeclarationNode::Union:
-      ret = new UnionInstType( type->buildQualifiers(), type->aggregate->name );
-      break;
-
-    case DeclarationNode::Context:
-      ret = new ContextInstType( type->buildQualifiers(), type->aggregate->name );
-      break;
-
-    default:
-      assert( false );
-    }
-    buildList( type->aggregate->actuals, ret->get_parameters() );
-    return ret;
-  }
-  
-  case TypeData::Symbolic: {
-    TypeInstType *ret = new TypeInstType( type->buildQualifiers(), type->symbolic->name, false );
-    buildList( type->symbolic->actuals, ret->get_parameters() );
-    return ret;
-  }
-  
-  default:
-    return type->build();
-  }
-}
-
-Declaration::StorageClass 
-DeclarationNode::buildStorageClass() const
-{
-  static const Declaration::StorageClass scMap[] = {  
-    Declaration::Static,
-    Declaration::Auto,
-    Declaration::Extern,
-    Declaration::Register,
-    Declaration::NoStorageClass, // inline
-    Declaration::Fortran
-  };  
-  
-  Declaration::StorageClass ret = Declaration::NoStorageClass;
-  for( std::list< StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
-    assert( unsigned( *i ) < sizeof( scMap ) / sizeof( scMap[0] ) );
-    if( *i == Inline ) continue;
-    if( ret == Declaration::NoStorageClass ) {
-      ret = scMap[ *i ];
-    } else {
-      throw SemanticError( "invalid combination of storage classes in declaration of ", this );
-    }
-  }
-  return ret;
-}
-
-bool 
-DeclarationNode::buildInline() const
-{
-  std::list< StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), Inline );
-  if( first == storageClasses.end() ) {
+	std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline );
+	if ( next == storageClasses.end() ) {
+	    return true;
+	} else {
+	    throw SemanticError( "duplicate inline specification in declaration of ", this );
+	}
+    }
+    // we should never get here
     return false;
-  } else {
-    std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline );
-    if( next == storageClasses.end() ) {
-      return true;
-    } else {
-      throw SemanticError( "duplicate inline specification in declaration of ", this );
-    }
-  }
-  // we should never get here
-  return false;
-}
+}
Index: translator/Parser/ExpressionNode.cc
===================================================================
--- translator/Parser/ExpressionNode.cc	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/Parser/ExpressionNode.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -1,3 +1,2 @@
-/* -*- C++ -*- */
 #include <cassert>
 #include <cctype>
@@ -15,275 +14,235 @@
 using namespace std;
 
-ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) {
-}
+ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) {}
 
 ExpressionNode::ExpressionNode(string *name_) : ParseNode( *name_ ), argName( 0 ) {
-  delete name_;
-}
-
-ExpressionNode::ExpressionNode( const ExpressionNode &other )
-  : ParseNode( other.name )
-{
-  if( other.argName ) {
-    argName = other.argName->clone();
-  } else {
-    argName = 0;
-  }
+    delete name_;
+}
+
+ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ) {
+    if ( other.argName ) {
+	argName = other.argName->clone();
+    } else {
+	argName = 0;
+    }
 }
 
 ExpressionNode * ExpressionNode::set_asArgName( std::string *aName ) {
-  argName = new VarRefNode(aName);
-  return this;
+    argName = new VarRefNode(aName);
+    return this;
 }
 
 ExpressionNode * ExpressionNode::set_asArgName( ExpressionNode *aDesignator ) {
-  argName = aDesignator;
-  return this;
+    argName = aDesignator;
+    return this;
 }
 
 void ExpressionNode::printDesignation( std::ostream &os, int indent ) const {
-  if( argName ) {
-    os << string(' ', indent) << "(designated by:  ";
-    argName->printOneLine(os, indent );
-    os << ")" << std::endl;
-  }
-}
-
-NullExprNode::NullExprNode()
-{
-}
-
-NullExprNode *
-NullExprNode::clone() const
-{
-  return new NullExprNode();
-}
-
-void
-NullExprNode::print(std::ostream & os, int indent) const
-{
-  printDesignation(os);
-  os << "null expression";
-}
-
-void
-NullExprNode::printOneLine(std::ostream & os, int indent) const
-{
-  printDesignation(os);
-  os << "null";
-}
-
-Expression *
-NullExprNode::build() const
-{
-  return 0;
+    if ( argName ) {
+	os << string(' ', indent) << "(designated by:  ";
+	argName->printOneLine(os, indent );
+	os << ")" << std::endl;
+    }
+}
+
+NullExprNode::NullExprNode() {}
+
+NullExprNode *NullExprNode::clone() const {
+    return new NullExprNode();
+}
+
+void NullExprNode::print(std::ostream & os, int indent) const {
+    printDesignation(os);
+    os << "null expression";
+}
+
+void NullExprNode::printOneLine(std::ostream & os, int indent) const {
+    printDesignation(os);
+    os << "null";
+}
+
+Expression *NullExprNode::build() const {
+    return 0;
 }
 
 CommaExprNode *ExpressionNode::add_to_list(ExpressionNode *exp){
-  return new CommaExprNode(this, exp );
+    return new CommaExprNode(this, exp );
 }
 
 //  enum ConstantNode::Type =  { Integer, Float, Character, String, Range }
 
-ConstantNode::ConstantNode(void) :
-  ExpressionNode(), sign(true), longs(0), size(0)
-{}
-
-ConstantNode::ConstantNode(string *name_) :
-  ExpressionNode(name_), sign(true), longs(0), size(0)
-{}
-
-ConstantNode::ConstantNode(Type t, string *inVal) :
-  type(t), sign(true), longs(0), size(0)
-{
-  if( inVal ) {
-    value = *inVal;
-    delete inVal;
-  } else {
-    value = "";
-  }
-
-  classify(value);
+ConstantNode::ConstantNode(void) : ExpressionNode(), sign(true), longs(0), size(0) {}
+
+ConstantNode::ConstantNode(string *name_) : ExpressionNode(name_), sign(true), longs(0), size(0) {}
+
+ConstantNode::ConstantNode(Type t, string *inVal) : type(t), sign(true), longs(0), size(0) {
+    if ( inVal ) {
+	value = *inVal;
+	delete inVal;
+    } else {
+	value = "";
+    }
+
+    classify(value);
 }
 
 ConstantNode::ConstantNode( const ConstantNode &other )
-  : ExpressionNode( other ), type( other.type ), value( other.value ), sign( other.sign ), base( other.base ), longs( other.longs ), size( other.size )
-{
+    : ExpressionNode( other ), type( other.type ), value( other.value ), sign( other.sign ), base( other.base ), longs( other.longs ), size( other.size ) {
 }
 
 // for some reason, std::tolower doesn't work as an argument to std::transform in g++ 3.1
-inline char
-tolower_hack( char c )
-{
-  return std::tolower( c );
+inline char tolower_hack( char c ) {
+    return std::tolower( c );
 }
 
 void ConstantNode::classify(std::string &str){
-  switch(type){
-    case Integer:
-    case Float:
-      {
-	std::string sfx("");
-	char c;
-	int i = str.length() - 1;
-
-	while( i >= 0 && !isxdigit(c = str.at(i--)) )
-	  sfx += c;
-
-	value = str.substr( 0, i + 2 );
-
-	// get rid of underscores
-	value.erase(remove(value.begin(), value.end(), '_'), value.end());
-
-	std::transform(sfx.begin(), sfx.end(), sfx.begin(), tolower_hack);
-
-	if( sfx.find("ll") != string::npos ){
-	  longs = 2;
-	} else if (sfx.find("l") != string::npos ){
-	  longs = 1;
+    switch (type){
+      case Integer:
+      case Float:
+	{
+	    std::string sfx("");
+	    char c;
+	    int i = str.length() - 1;
+
+	    while ( i >= 0 && !isxdigit(c = str.at(i--)) )
+		sfx += c;
+
+	    value = str.substr( 0, i + 2 );
+
+	    // get rid of underscores
+	    value.erase(remove(value.begin(), value.end(), '_'), value.end());
+
+	    std::transform(sfx.begin(), sfx.end(), sfx.begin(), tolower_hack);
+
+	    if ( sfx.find("ll") != string::npos ){
+		longs = 2;
+	    } else if (sfx.find("l") != string::npos ){
+		longs = 1;
+	    }
+
+	    assert((longs >= 0) && (longs <= 2));
+
+	    if ( sfx.find("u") != string::npos )
+		sign = false;
+
+	    break;
 	}
-
-	assert((longs >= 0) && (longs <= 2));
-
-	if( sfx.find("u") != string::npos )
-	  sign = false;
-
+      case Character:
+	{
+	    // remove underscores from hex and oct escapes
+	    if (str.substr(1,2) == "\\x")
+		value.erase(remove(value.begin(), value.end(), '_'), value.end());
+
+	    break;
+	}
+      default:
+	// shouldn't be here
+	;
+    }
+}
+
+ConstantNode::Type ConstantNode::get_type(void) const {
+    return type;
+}
+
+ConstantNode *ConstantNode::append( std::string *newValue ) {
+    if ( newValue ) {
+	if (type == String){
+	    std::string temp = *newValue;
+	    value.resize( value.size() - 1 );
+	    value += newValue->substr(1, newValue->size());
+	} else
+	    value += *newValue;
+
+	delete newValue;
+    }
+    return this;
+}
+
+void ConstantNode::printOneLine(std::ostream &os, int indent ) const {
+    os << string(indent, ' ');
+    printDesignation(os);
+
+    switch ( type ) {
+	/* integers */
+      case Integer:
+	os << value ;
 	break;
-      }
-    case Character:
-      {
-	// remove underscores from hex and oct escapes
-	if(str.substr(1,2) == "\\x")
-	  value.erase(remove(value.begin(), value.end(), '_'), value.end());
-
+      case Float:
+	os << value ;
 	break;
-      }
-  default:
-    // shouldn't be here
-    ;
-  }
-}
-
-ConstantNode::Type ConstantNode::get_type(void) const {
-  return type;
-}
-
-ConstantNode*
-ConstantNode::append( std::string *newValue )
-{
-  if( newValue ) {
-    if (type == String){
-      std::string temp = *newValue;
-      value.resize( value.size() - 1 );
-      value += newValue->substr(1, newValue->size());
-    } else
-      value += *newValue;
-
-    delete newValue;
-  }
-  return this;
-}
-
-void ConstantNode::printOneLine(std::ostream &os, int indent ) const
-{
-  os << string(indent, ' ');
-  printDesignation(os);
-
-  switch( type ) {
-    /* integers */
-  case Integer:
-      os << value ;
-      break;
-  case Float:
-    os << value ;
-    break;
-
-  case Character:
-    os << "'" << value << "'";
-    break;
-
-  case String:
-    os << '"' << value << '"';
-    break;
-  }
-
-  os << ' ';
-}
-
-void ConstantNode::print(std::ostream &os, int indent ) const
-{
-  printOneLine( os, indent );
-  os << endl;
+
+      case Character:
+	os << "'" << value << "'";
+	break;
+
+      case String:
+	os << '"' << value << '"';
+	break;
+    }
+
+    os << ' ';
+}
+
+void ConstantNode::print(std::ostream &os, int indent ) const {
+    printOneLine( os, indent );
+    os << endl;
 }
 
 Expression *ConstantNode::build() const {
-  ::Type::Qualifiers q;
-  BasicType *bt;
-
-  switch(get_type()){
-  case Integer:
-    /* Cfr. standard 6.4.4.1 */
-    //bt.set_kind(BasicType::SignedInt);
-    bt = new BasicType(q, BasicType::SignedInt);
-    break;
-
-  case Float:
-    bt = new BasicType(q, BasicType::Float);
-    break;
-
-  case Character:
-    bt = new BasicType(q, BasicType::Char);
-    break;
-
-  case String:
-    // string should probably be a primitive type
-    ArrayType *at;
-    std::string value = get_value();
-    at = new ArrayType(q, new BasicType(q, BasicType::Char),
-				new ConstantExpr( Constant( new BasicType(q, BasicType::SignedInt),
-									      toString( value.size() - 1 ) ) ),  // account for '\0'
-				false, false );
-
-    return new ConstantExpr( Constant(at, value), maybeBuild< Expression >( get_argName() ) );
-  }
-
-  return new ConstantExpr(  Constant(bt, get_value()),  maybeBuild< Expression >( get_argName() ) );
-}
-
+    ::Type::Qualifiers q;
+    BasicType *bt;
+
+    switch (get_type()){
+      case Integer:
+	/* Cfr. standard 6.4.4.1 */
+	//bt.set_kind(BasicType::SignedInt);
+	bt = new BasicType(q, BasicType::SignedInt);
+	break;
+      case Float:
+	bt = new BasicType(q, BasicType::Float);
+	break;
+      case Character:
+	bt = new BasicType(q, BasicType::Char);
+	break;
+      case String:
+	// string should probably be a primitive type
+	ArrayType *at;
+	std::string value = get_value();
+	at = new ArrayType(q, new BasicType(q, BasicType::Char),
+			   new ConstantExpr( Constant( new BasicType(q, BasicType::SignedInt),
+						       toString( value.size() - 1 ) ) ),  // account for '\0'
+			   false, false );
+	return new ConstantExpr( Constant(at, value), maybeBuild< Expression >( get_argName() ) );
+    }
+    return new ConstantExpr(  Constant(bt, get_value()),  maybeBuild< Expression >( get_argName() ) );
+}
 
 VarRefNode::VarRefNode() : isLabel(false) {}
 
-VarRefNode::VarRefNode(string *name_, bool labelp) :
-  ExpressionNode(name_), isLabel(labelp) {}
-
-VarRefNode::VarRefNode( const VarRefNode &other )
-  : ExpressionNode( other ), isLabel( other.isLabel )
-{
+VarRefNode::VarRefNode(string *name_, bool labelp) : ExpressionNode(name_), isLabel(labelp) {}
+
+VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) {
 }
 
 Expression *VarRefNode::build() const {
-  return new NameExpr( get_name(), maybeBuild< Expression >( get_argName() ) );
+    return new NameExpr( get_name(), maybeBuild< Expression >( get_argName() ) );
 }
 
 void VarRefNode::printOneLine(std::ostream &os, int indent ) const {
-  printDesignation(os);
-  os << get_name() << ' ';
+    printDesignation(os);
+    os << get_name() << ' ';
 }
 
 void VarRefNode::print(std::ostream &os, int indent ) const {
-  printDesignation(os);
-  os << '\r' << string(indent, ' ') << "Referencing: ";
-
-  os << "Variable: " << get_name();
-
-  os << endl;
-}
-
-
-OperatorNode::OperatorNode(Type t):type(t) {}
-
-OperatorNode::OperatorNode( const OperatorNode &other )
-  : ExpressionNode( other ), type( other.type )
-{
+    printDesignation(os);
+    os << '\r' << string(indent, ' ') << "Referencing: ";
+    os << "Variable: " << get_name();
+    os << endl;
+}
+
+OperatorNode::OperatorNode(Type t) : type(t) {}
+
+OperatorNode::OperatorNode( const OperatorNode &other ) : ExpressionNode( other ), type( other.type ) {
 }
 
@@ -291,514 +250,464 @@
 
 OperatorNode::Type OperatorNode::get_type(void) const{
-  return type;
-}
-
-void OperatorNode::printOneLine( std::ostream &os, int indent ) const
-{
-  printDesignation(os);
-  os << OpName[ type ] << ' ';
+    return type;
+}
+
+void OperatorNode::printOneLine( std::ostream &os, int indent ) const {
+    printDesignation(os);
+    os << OpName[ type ] << ' ';
 }
 
 void OperatorNode::print( std::ostream &os, int indent ) const{
-  printDesignation(os);
-  os << '\r' << string(indent, ' ') << "Operator: " << OpName[type] << endl;
-
-  return;
+    printDesignation(os);
+    os << '\r' << string(indent, ' ') << "Operator: " << OpName[type] << endl;
+    return;
 }
 
 std::string OperatorNode::get_typename(void) const{
-  return string(OpName[ type ]);
-}
-
-const char *OperatorNode::OpName[] =
-  { "TupleC",  "Comma", "TupleFieldSel",// "TuplePFieldSel", //n-adic
+    return string(OpName[ type ]);
+}
+
+const char *OperatorNode::OpName[] = {
+    "TupleC",  "Comma", "TupleFieldSel",// "TuplePFieldSel", //n-adic
     // triadic
     "Cond",   "NCond",
     // diadic
     "SizeOf",      "AlignOf", "Attr", "CompLit", "Plus",    "Minus",   "Mul",     "Div",     "Mod",      "Or",
-      "And",       "BitOr",   "BitAnd",  "Xor",     "Cast",    "LShift",  "RShift",  "LThan",   "GThan",
-      "LEThan",    "GEThan", "Eq",      "Neq",     "Assign",  "MulAssn", "DivAssn", "ModAssn", "PlusAssn",
-      "MinusAssn", "LSAssn", "RSAssn",  "AndAssn", "ERAssn",  "OrAssn",  "Index",   "FieldSel","PFieldSel",
-      "Range",
+    "And",       "BitOr",   "BitAnd",  "Xor",     "Cast",    "LShift",  "RShift",  "LThan",   "GThan",
+    "LEThan",    "GEThan", "Eq",      "Neq",     "Assign",  "MulAssn", "DivAssn", "ModAssn", "PlusAssn",
+    "MinusAssn", "LSAssn", "RSAssn",  "AndAssn", "ERAssn",  "OrAssn",  "Index",   "FieldSel","PFieldSel",
+    "Range",
     // monadic
     "UnPlus", "UnMinus", "AddressOf", "PointTo", "Neg", "BitNeg", "Incr", "IncrPost", "Decr", "DecrPost", "LabelAddress"
-  };
+};
 
 CompositeExprNode::CompositeExprNode(void) : ExpressionNode(), function( 0 ), arguments( 0 ) {
 }
 
-CompositeExprNode::CompositeExprNode(string *name_) : ExpressionNode(name_), function( 0 ), arguments( 0 )
-{
+CompositeExprNode::CompositeExprNode(string *name_) : ExpressionNode(name_), function( 0 ), arguments( 0 ) {
 }
 
 CompositeExprNode::CompositeExprNode(ExpressionNode *f, ExpressionNode *args):
-  function(f), arguments(args) {
+    function(f), arguments(args) {
 }
 
 CompositeExprNode::CompositeExprNode(ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2):
-  function(f), arguments(arg1) {
-  arguments->set_link(arg2);
-}
-
-CompositeExprNode::CompositeExprNode( const CompositeExprNode &other )
-  : ExpressionNode( other ), function( maybeClone( other.function ) )
-{
-  ParseNode *cur = other.arguments;
-  while( cur ) {
-    if( arguments ) {
-      arguments->set_link( cur->clone() );
-    } else {
-      arguments = (ExpressionNode*)cur->clone();
-    }
-    cur = cur->get_link();
-  }
-}
-
-CompositeExprNode::~CompositeExprNode()
-{
-  delete function;
-  delete arguments;
+    function(f), arguments(arg1) {
+    arguments->set_link(arg2);
+}
+
+CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ) {
+    ParseNode *cur = other.arguments;
+    while ( cur ) {
+	if ( arguments ) {
+	    arguments->set_link( cur->clone() );
+	} else {
+	    arguments = (ExpressionNode*)cur->clone();
+	}
+	cur = cur->get_link();
+    }
+}
+
+CompositeExprNode::~CompositeExprNode() {
+    delete function;
+    delete arguments;
 }
 
 // the names that users use to define operator functions
-static const char *opFuncName[] =
-  { "",  "", "",
+static const char *opFuncName[] = {
+    "",  "", "",
     "",   "",
     // diadic
     "",   "", "", "", "?+?",    "?-?",   "?*?",     "?/?",     "?%?",     "",       "",
-      "?|?",  "?&?",  "?^?",     "",    "?<<?",  "?>>?",  "?<?",   "?>?",    "?<=?",
-      "?>=?", "?==?",      "?!=?",     "?=?",  "?*=?", "?/=?", "?%=?", "?+=?", "?-=?",
-      "?<<=?", "?>>=?",  "?&=?", "?^=?",  "?|=?",  "?[?]",   "","","Range",
+    "?|?",  "?&?",  "?^?",     "",    "?<<?",  "?>>?",  "?<?",   "?>?",    "?<=?",
+    "?>=?", "?==?",      "?!=?",     "?=?",  "?*=?", "?/=?", "?%=?", "?+=?", "?-=?",
+    "?<<=?", "?>>=?",  "?&=?", "?^=?",  "?|=?",  "?[?]",   "","","Range",
     // monadic
     "+?", "-?", "", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "LabAddress"
-  };
+};
 
 #include "utility.h"
+
 Expression *CompositeExprNode::build() const {
-  OperatorNode *op;
-  std::list<Expression *> args;
-
-  buildList(get_args(), args);
-
-  if (!( op = dynamic_cast<OperatorNode *>(function)) ){
-    // a function as opposed to an operator
-    return new UntypedExpr(function->build(), args, maybeBuild< Expression >( get_argName() ));
-
-  } else {
-
-    switch(op->get_type()){
-    case OperatorNode::Incr:
-    case OperatorNode::Decr:
-    case OperatorNode::IncrPost:
-    case OperatorNode::DecrPost:
-    case OperatorNode::Assign:
-    case OperatorNode::MulAssn:
-    case OperatorNode::DivAssn:
-    case OperatorNode::ModAssn:
-    case OperatorNode::PlusAssn:
-    case OperatorNode::MinusAssn:
-    case OperatorNode::LSAssn:
-    case OperatorNode::RSAssn:
-    case OperatorNode::AndAssn:
-    case OperatorNode::ERAssn:
-    case OperatorNode::OrAssn:
-      // the rewrite rules for these expressions specify that the first argument has its address taken
-      assert( !args.empty() );
-      args.front() = new AddressExpr( args.front() );
-      break;
-
-    default:
-      /* do nothing */
-      ;
-    }
-
-    switch(op->get_type()){
-
-    case OperatorNode::Incr:
-    case OperatorNode::Decr:
-    case OperatorNode::IncrPost:
-    case OperatorNode::DecrPost:
-    case OperatorNode::Assign:
-    case OperatorNode::MulAssn:
-    case OperatorNode::DivAssn:
-    case OperatorNode::ModAssn:
-    case OperatorNode::PlusAssn:
-    case OperatorNode::MinusAssn:
-    case OperatorNode::LSAssn:
-    case OperatorNode::RSAssn:
-    case OperatorNode::AndAssn:
-    case OperatorNode::ERAssn:
-    case OperatorNode::OrAssn:
-    case OperatorNode::Plus:
-    case OperatorNode::Minus:
-    case OperatorNode::Mul:
-    case OperatorNode::Div:
-    case OperatorNode::Mod:
-    case OperatorNode::BitOr:
-    case OperatorNode::BitAnd:
-    case OperatorNode::Xor:
-    case OperatorNode::LShift:
-    case OperatorNode::RShift:
-    case OperatorNode::LThan:
-    case OperatorNode::GThan:
-    case OperatorNode::LEThan:
-    case OperatorNode::GEThan:
-    case OperatorNode::Eq:
-    case OperatorNode::Neq:
-    case OperatorNode::Index:
-    case OperatorNode::Range:
-    case OperatorNode::UnPlus:
-    case OperatorNode::UnMinus:
-    case OperatorNode::PointTo:
-    case OperatorNode::Neg:
-    case OperatorNode::BitNeg:
-    case OperatorNode::LabelAddress:
-      return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args );
-
-    case OperatorNode::AddressOf:
-      assert( args.size() == 1 );
-      assert( args.front() );
-
-      return new AddressExpr( args.front() );
-
-    case OperatorNode::Cast:
-      {
-	TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args());
-	assert( arg );
-
-        DeclarationNode *decl_node = arg->get_decl();
-        ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>(arg->get_link());
-
-        Type *targetType = decl_node->buildType();
-        if( dynamic_cast< VoidType* >( targetType ) ) {
-          delete targetType;
-          return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
-        } else {
-          return new CastExpr(expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
-        }
-      }
-
-    case OperatorNode::FieldSel:
-      {
-	assert( args.size() == 2 );
-
-	NameExpr *member = dynamic_cast<NameExpr *>(args.back());
-	// TupleExpr *memberTup = dynamic_cast<TupleExpr *>(args.back());
-
-	if ( member != 0 )
-	  {
-	    UntypedMemberExpr *ret = new UntypedMemberExpr(member->get_name(), args.front());
-	    delete member;
-	    return ret;
-	  }
-	/* else if ( memberTup != 0 )
-	  {
-	    UntypedMemberExpr *ret = new UntypedMemberExpr(memberTup->get_name(), args.front());
-	    delete member;
-	    return ret;
-	    } */
+    OperatorNode *op;
+    std::list<Expression *> args;
+
+    buildList(get_args(), args);
+
+    if ( ! ( op = dynamic_cast<OperatorNode *>(function)) ) {
+	// a function as opposed to an operator
+	return new UntypedExpr(function->build(), args, maybeBuild< Expression >( get_argName() ));
+    } else {
+	switch (op->get_type()){
+	  case OperatorNode::Incr:
+	  case OperatorNode::Decr:
+	  case OperatorNode::IncrPost:
+	  case OperatorNode::DecrPost:
+	  case OperatorNode::Assign:
+	  case OperatorNode::MulAssn:
+	  case OperatorNode::DivAssn:
+	  case OperatorNode::ModAssn:
+	  case OperatorNode::PlusAssn:
+	  case OperatorNode::MinusAssn:
+	  case OperatorNode::LSAssn:
+	  case OperatorNode::RSAssn:
+	  case OperatorNode::AndAssn:
+	  case OperatorNode::ERAssn:
+	  case OperatorNode::OrAssn:
+	    // the rewrite rules for these expressions specify that the first argument has its address taken
+	    assert( !args.empty() );
+	    args.front() = new AddressExpr( args.front() );
+	    break;
+	  default:
+	    /* do nothing */
+	    ;
+	}
+
+	switch ( op->get_type() ) {
+	  case OperatorNode::Incr:
+	  case OperatorNode::Decr:
+	  case OperatorNode::IncrPost:
+	  case OperatorNode::DecrPost:
+	  case OperatorNode::Assign:
+	  case OperatorNode::MulAssn:
+	  case OperatorNode::DivAssn:
+	  case OperatorNode::ModAssn:
+	  case OperatorNode::PlusAssn:
+	  case OperatorNode::MinusAssn:
+	  case OperatorNode::LSAssn:
+	  case OperatorNode::RSAssn:
+	  case OperatorNode::AndAssn:
+	  case OperatorNode::ERAssn:
+	  case OperatorNode::OrAssn:
+	  case OperatorNode::Plus:
+	  case OperatorNode::Minus:
+	  case OperatorNode::Mul:
+	  case OperatorNode::Div:
+	  case OperatorNode::Mod:
+	  case OperatorNode::BitOr:
+	  case OperatorNode::BitAnd:
+	  case OperatorNode::Xor:
+	  case OperatorNode::LShift:
+	  case OperatorNode::RShift:
+	  case OperatorNode::LThan:
+	  case OperatorNode::GThan:
+	  case OperatorNode::LEThan:
+	  case OperatorNode::GEThan:
+	  case OperatorNode::Eq:
+	  case OperatorNode::Neq:
+	  case OperatorNode::Index:
+	  case OperatorNode::Range:
+	  case OperatorNode::UnPlus:
+	  case OperatorNode::UnMinus:
+	  case OperatorNode::PointTo:
+	  case OperatorNode::Neg:
+	  case OperatorNode::BitNeg:
+	  case OperatorNode::LabelAddress:
+	    return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args );
+	  case OperatorNode::AddressOf:
+	    assert( args.size() == 1 );
+	    assert( args.front() );
+
+	    return new AddressExpr( args.front() );
+	  case OperatorNode::Cast:
+	    {
+		TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args());
+		assert( arg );
+
+		DeclarationNode *decl_node = arg->get_decl();
+		ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>(arg->get_link());
+
+		Type *targetType = decl_node->buildType();
+		if ( dynamic_cast< VoidType* >( targetType ) ) {
+		    delete targetType;
+		    return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
+		} else {
+		    return new CastExpr(expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
+		}
+	    }
+	  case OperatorNode::FieldSel:
+	    {
+		assert( args.size() == 2 );
+
+		NameExpr *member = dynamic_cast<NameExpr *>(args.back());
+		// TupleExpr *memberTup = dynamic_cast<TupleExpr *>(args.back());
+
+		if ( member != 0 )
+		    {
+			UntypedMemberExpr *ret = new UntypedMemberExpr(member->get_name(), args.front());
+			delete member;
+			return ret;
+		    }
+		/* else if ( memberTup != 0 )
+		   {
+		   UntypedMemberExpr *ret = new UntypedMemberExpr(memberTup->get_name(), args.front());
+		   delete member;
+		   return ret;
+		   } */
+		else
+		    assert( false );
+	    }
+	  case OperatorNode::PFieldSel:
+	    {
+		assert( args.size() == 2 );
+
+		NameExpr *member = dynamic_cast<NameExpr *>(args.back());  // modify for Tuples   xxx
+		assert( member != 0 );
+
+		UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+		deref->get_args().push_back( args.front() );
+
+		UntypedMemberExpr *ret = new UntypedMemberExpr(member->get_name(), deref);
+		delete member;
+		return ret;
+	    }
+	  case OperatorNode::AlignOf:
+	  case OperatorNode::SizeOf:
+	    {
+/// 	bool isSizeOf = (op->get_type() == OperatorNode::SizeOf);
+
+		if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args()) ) {
+		    return new SizeofExpr(arg->get_decl()->buildType());
+		} else {
+		    return new SizeofExpr(args.front());
+		}
+	    }
+	  case OperatorNode::Attr:
+	    {
+		VarRefNode *var = dynamic_cast<VarRefNode *>(get_args());
+		assert( var );
+		if ( !get_args()->get_link() ) {
+		    return new AttrExpr(var->build(), (Expression*)0);
+		} else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args()->get_link()) ) {
+		    return new AttrExpr(var->build(), arg->get_decl()->buildType());
+		} else {
+		    return new AttrExpr(var->build(), args.back());
+		}
+	    }
+	  case OperatorNode::CompLit:
+	    throw UnimplementedError( "C99 compound literals" );
+	    // the short-circuited operators
+	  case OperatorNode::Or:
+	  case OperatorNode::And:
+	    assert(args.size() == 2);
+	    return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), (op->get_type() == OperatorNode::And) );
+	  case OperatorNode::Cond:
+	    {
+		assert(args.size() == 3);
+		std::list< Expression* >::const_iterator i = args.begin();
+		Expression *arg1 = notZeroExpr( *i++ );
+		Expression *arg2 = *i++;
+		Expression *arg3 = *i++;
+		return new ConditionalExpr( arg1, arg2, arg3 );
+	    }
+	  case OperatorNode::NCond:
+	    throw UnimplementedError( "GNU 2-argument conditional expression" );
+	  case OperatorNode::Comma:
+	    {
+		assert(args.size() == 2);
+		std::list< Expression* >::const_iterator i = args.begin();
+		Expression *ret = *i++;
+		while ( i != args.end() ) {
+		    ret = new CommaExpr( ret, *i++ );
+		}
+		return ret;
+	    }
+	    // Tuples
+	  case OperatorNode::TupleC:
+	    {
+		TupleExpr *ret = new TupleExpr();
+		std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) );
+		return ret;
+	    }
+	  default:
+	    // shouldn't happen
+	    return 0;
+	}
+    }
+}
+
+void CompositeExprNode::printOneLine(std::ostream &os, int indent) const {
+    printDesignation(os);
+    os << "( ";
+    function->printOneLine( os, indent );
+    for( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
+	cur->printOneLine( os, indent );
+    }
+    os << ") ";
+}
+
+void CompositeExprNode::print(std::ostream &os, int indent) const {
+    printDesignation(os);
+    os << '\r' << string(indent, ' ') << "Application of: " << endl;
+    function->print( os, indent + ParseNode::indent_by );
+
+    os << '\r' << string(indent, ' ') ;
+    if ( arguments ) {
+	os << "... on arguments: " << endl;
+	arguments->printList(os, indent + ParseNode::indent_by);
+    } else
+	os << "... on no arguments: " << endl;
+}
+
+void CompositeExprNode::set_function(ExpressionNode *f){
+    function = f;
+}
+
+void CompositeExprNode::set_args(ExpressionNode *args){
+    arguments = args;
+}
+
+ExpressionNode *CompositeExprNode::get_function(void) const {
+    return function;
+}
+
+ExpressionNode *CompositeExprNode::get_args(void) const {
+    return arguments;
+}
+
+void CompositeExprNode::add_arg(ExpressionNode *arg){
+    if (arguments)
+	arguments->set_link(arg);
+    else
+	set_args(arg);
+}
+
+CommaExprNode::CommaExprNode(): CompositeExprNode(new OperatorNode(OperatorNode::Comma)) {}
+
+CommaExprNode::CommaExprNode(ExpressionNode *exp) : CompositeExprNode( new OperatorNode(OperatorNode::Comma), exp ) {
+}
+
+CommaExprNode::CommaExprNode(ExpressionNode *exp1, ExpressionNode *exp2) : CompositeExprNode(new OperatorNode(OperatorNode::Comma), exp1, exp2) {
+}
+
+CommaExprNode *CommaExprNode::add_to_list(ExpressionNode *exp){
+    add_arg(exp);
+
+    return this;
+}
+
+CommaExprNode::CommaExprNode( const CommaExprNode &other ) : CompositeExprNode( other ) {
+}
+
+ValofExprNode::ValofExprNode(StatementNode *s): body(s) {}
+
+ValofExprNode::ValofExprNode( const ValofExprNode &other ) : ExpressionNode( other ), body( maybeClone( body ) ) {
+}
+
+ValofExprNode::~ValofExprNode() {
+    delete body;
+}
+
+void ValofExprNode::print( std::ostream &os, int indent ) const {
+    printDesignation(os);
+    os << string(indent, ' ') << "Valof Expression:" << std::endl;
+    get_body()->print(os, indent + 4);
+}
+
+void ValofExprNode::printOneLine( std::ostream &, int indent ) const {
+    assert( false );
+}
+
+Expression *ValofExprNode::build() const {
+    return new UntypedValofExpr ( get_body()->build(), maybeBuild< Expression >( get_argName() ) );
+}
+
+ForCtlExprNode::ForCtlExprNode(ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr) throw (SemanticError) : condition(cond), change(incr) {
+    if ( init_ == 0 )
+	init = 0;
+    else {
+	DeclarationNode *decl;
+	ExpressionNode *exp;
+
+	if ((decl = dynamic_cast<DeclarationNode *>(init_)) != 0)
+	    init = new StatementNode(decl);
+	else if ((exp = dynamic_cast<ExpressionNode *>(init_)) != 0)
+	    init = new StatementNode(StatementNode::Exp, exp);
 	else
-	  assert( false );
-      }
-
-    case OperatorNode::PFieldSel:
-      {
-	assert( args.size() == 2 );
-
-	NameExpr *member = dynamic_cast<NameExpr *>(args.back());  // modify for Tuples   xxx
-	assert( member != 0 );
-
-	UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-	deref->get_args().push_back( args.front() );
-
-	UntypedMemberExpr *ret = new UntypedMemberExpr(member->get_name(), deref);
-	delete member;
-	return ret;
-      }
-
-    case OperatorNode::AlignOf:
-    case OperatorNode::SizeOf:
-      {
-/// 	bool isSizeOf = (op->get_type() == OperatorNode::SizeOf);
-
-	if( TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args()) ) {
-          return new SizeofExpr(arg->get_decl()->buildType());
-        } else {
-	  return new SizeofExpr(args.front());
-        }
-      }
-    
-    case OperatorNode::Attr:
-      {
-        VarRefNode *var = dynamic_cast<VarRefNode *>(get_args());
-        assert( var );
-        if( !get_args()->get_link() ) {
-          return new AttrExpr(var->build(), (Expression*)0);
-	} else if( TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args()->get_link()) ) {
-          return new AttrExpr(var->build(), arg->get_decl()->buildType());
-        } else {
-	  return new AttrExpr(var->build(), args.back());
-        }
-      }
-    
-
-    case OperatorNode::CompLit:
-      throw UnimplementedError( "C99 compound literals" );
-
-      // the short-circuited operators
-    case OperatorNode::Or:
-    case OperatorNode::And:
-      assert(args.size() == 2);
-      return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), (op->get_type() == OperatorNode::And) );
-
-    case OperatorNode::Cond:
-      {
-        assert(args.size() == 3);
-        std::list< Expression* >::const_iterator i = args.begin();
-        Expression *arg1 = notZeroExpr( *i++ );
-        Expression *arg2 = *i++;
-        Expression *arg3 = *i++;
-        return new ConditionalExpr( arg1, arg2, arg3 );
-      }
-
-    case OperatorNode::NCond:
-      throw UnimplementedError( "GNU 2-argument conditional expression" );
-
-    case OperatorNode::Comma:
-      {
-        assert(args.size() == 2);
-        std::list< Expression* >::const_iterator i = args.begin();
-        Expression *ret = *i++;
-        while( i != args.end() ) {
-          ret = new CommaExpr( ret, *i++ );
-        }
-        return ret;
-      }
-
-      // Tuples
-    case OperatorNode::TupleC:
-      {
-        TupleExpr *ret = new TupleExpr();
-        std::copy( args.begin(), args.end(), back_inserter( ret->get_exprs() ) );
-        return ret;
-      }
-
-    default:
-      // shouldn't happen
-      return 0;
-    }
-  }
-}
-
-void CompositeExprNode::printOneLine(std::ostream &os, int indent) const
-{
-  printDesignation(os);
-  os << "( ";
-  function->printOneLine( os, indent );
-  for( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
-    cur->printOneLine( os, indent );
-  }
-  os << ") ";
-}
-
-void CompositeExprNode::print(std::ostream &os, int indent) const
-{
-  printDesignation(os);
-  os << '\r' << string(indent, ' ') << "Application of: " << endl;
-  function->print( os, indent + ParseNode::indent_by );
-
-  os << '\r' << string(indent, ' ') ;
-  if( arguments ) {
-    os << "... on arguments: " << endl;
-    arguments->printList(os, indent + ParseNode::indent_by);
-  } else
-    os << "... on no arguments: " << endl;
-}
-
-void CompositeExprNode::set_function(ExpressionNode *f){
-  function = f;
-}
-
-void CompositeExprNode::set_args(ExpressionNode *args){
-  arguments = args;
-}
-
-ExpressionNode *CompositeExprNode::get_function(void) const {
-  return function;
-}
-
-ExpressionNode *CompositeExprNode::get_args(void) const {
-  return arguments;
-}
-
-void CompositeExprNode::add_arg(ExpressionNode *arg){
-  if(arguments)
-    arguments->set_link(arg);
-  else
-    set_args(arg);
-}
-
-CommaExprNode::CommaExprNode(): CompositeExprNode(new OperatorNode(OperatorNode::Comma)) {}
-
-CommaExprNode::CommaExprNode(ExpressionNode *exp)
-  : CompositeExprNode( new OperatorNode(OperatorNode::Comma), exp )
- {
- }
-
-CommaExprNode::CommaExprNode(ExpressionNode *exp1, ExpressionNode *exp2)
-  : CompositeExprNode(new OperatorNode(OperatorNode::Comma), exp1, exp2)
-{
-}
-
-CommaExprNode *CommaExprNode::add_to_list(ExpressionNode *exp){
-  add_arg(exp);
-
-  return this;
-}
-
-CommaExprNode::CommaExprNode( const CommaExprNode &other )
-  : CompositeExprNode( other )
-{
-}
-
-ValofExprNode::ValofExprNode(StatementNode *s): body(s) {}
-
-ValofExprNode::ValofExprNode( const ValofExprNode &other )
-  : ExpressionNode( other ), body( maybeClone( body ) )
-{
-}
-
-ValofExprNode::~ValofExprNode() {
-  delete body;
-}
-
-void ValofExprNode::print( std::ostream &os, int indent ) const {
-  printDesignation(os);
-  os << string(indent, ' ') << "Valof Expression:" << std::endl;
-  get_body()->print(os, indent + 4);
-}
-
-void ValofExprNode::printOneLine( std::ostream &, int indent ) const
-{
-  assert( false );
-}
-
-Expression *ValofExprNode::build() const {
-  return new UntypedValofExpr ( get_body()->build(), maybeBuild< Expression >( get_argName() ) );
-}
-
-ForCtlExprNode::ForCtlExprNode(ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr)
-  throw (SemanticError)
-  : condition(cond), change(incr)
-{
-  if(init_ == 0)
-    init = 0;
-  else {
-    DeclarationNode *decl;
-    ExpressionNode *exp;
-
-    if((decl = dynamic_cast<DeclarationNode *>(init_)) != 0)
-      init = new StatementNode(decl);
-    else if((exp = dynamic_cast<ExpressionNode *>(init_)) != 0)
-      init = new StatementNode(StatementNode::Exp, exp);
-    else
-      throw SemanticError("Error in for control expression");
-  }
+	    throw SemanticError("Error in for control expression");
+    }
 }
 
 ForCtlExprNode::ForCtlExprNode( const ForCtlExprNode &other )
-  : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) )
-{
+    : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) ) {
 }
 
 ForCtlExprNode::~ForCtlExprNode(){
-  delete init;
-  delete condition;
-  delete change;
+    delete init;
+    delete condition;
+    delete change;
 }
 
 Expression *ForCtlExprNode::build() const {
-  // this shouldn't be used!
-  assert( false );
-  return 0;
+    // this shouldn't be used!
+    assert( false );
+    return 0;
 }
 
 void ForCtlExprNode::print( std::ostream &os, int indent ) const{
-  os << string(indent,' ') << "For Control Expression -- : " << endl;
-
-  os << "\r" << string(indent + 2,' ') << "initialization: ";
-  if(init != 0)
-    init->print(os, indent + 4);
-
-  os << "\n\r" << string(indent + 2,' ') << "condition: ";
-  if(condition != 0)
-    condition->print(os, indent + 4);
-  os << "\n\r" << string(indent + 2,' ') << "increment: ";
-  if(change != 0)
-    change->print(os, indent + 4);
-}
-
-void
-ForCtlExprNode::printOneLine( std::ostream &, int indent ) const
-{
-  assert( false );
+    os << string(indent,' ') << "For Control Expression -- : " << endl;
+
+    os << "\r" << string(indent + 2,' ') << "initialization: ";
+    if (init != 0)
+	init->print(os, indent + 4);
+
+    os << "\n\r" << string(indent + 2,' ') << "condition: ";
+    if (condition != 0)
+	condition->print(os, indent + 4);
+    os << "\n\r" << string(indent + 2,' ') << "increment: ";
+    if (change != 0)
+	change->print(os, indent + 4);
+}
+
+void ForCtlExprNode::printOneLine( std::ostream &, int indent ) const {
+    assert( false );
 }
 
 TypeValueNode::TypeValueNode(DeclarationNode *decl)
-  : decl( decl )
-{
+    : decl( decl ) {
 }
 
 TypeValueNode::TypeValueNode( const TypeValueNode &other )
-  : ExpressionNode( other ), decl( maybeClone( other.decl ) )
-{
-}
-
-Expression *
-TypeValueNode::build() const
-{
-  return new TypeExpr( decl->buildType() );
-}
-
-void
-TypeValueNode::print(std::ostream &os, int indent) const
-{
-  os << std::string( indent, ' ' ) << "Type:";
-  get_decl()->print(os, indent + 2);
-}
-
-void
-TypeValueNode::printOneLine(std::ostream &os, int indent) const
-{
-  os << "Type:";
-  get_decl()->print(os, indent + 2);
-}
-
-ExpressionNode *flattenCommas( ExpressionNode *list )
-{
-  if( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) )
-    {
-      OperatorNode *op;
-           if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::Comma) )
-	     {
-	         if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
-		   composite->add_arg( next );
-		 return flattenCommas( composite->get_args() );
-	     }
-    }
-
-  if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
-    list->set_next( flattenCommas( next ) );
-
-  return list;
-}
-
-ExpressionNode *tupleContents( ExpressionNode *tuple )
-{
-  if( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) {
-    OperatorNode *op = 0;
-    if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::TupleC) )
-      return composite->get_args();
-  }
-  return tuple;
-}
+    : ExpressionNode( other ), decl( maybeClone( other.decl ) ) {
+}
+
+Expression *TypeValueNode::build() const {
+    return new TypeExpr( decl->buildType() );
+}
+
+void TypeValueNode::print(std::ostream &os, int indent) const {
+    os << std::string( indent, ' ' ) << "Type:";
+    get_decl()->print(os, indent + 2);
+}
+
+void TypeValueNode::printOneLine(std::ostream &os, int indent) const {
+    os << "Type:";
+    get_decl()->print(os, indent + 2);
+}
+
+ExpressionNode *flattenCommas( ExpressionNode *list ) {
+    if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) )
+	{
+	    OperatorNode *op;
+	    if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::Comma) )
+		{
+		    if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
+			composite->add_arg( next );
+		    return flattenCommas( composite->get_args() );
+		}
+	}
+
+    if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
+	list->set_next( flattenCommas( next ) );
+
+    return list;
+}
+
+ExpressionNode *tupleContents( ExpressionNode *tuple ) {
+    if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) {
+	OperatorNode *op = 0;
+	if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::TupleC) )
+	    return composite->get_args();
+    }
+    return tuple;
+}
Index: translator/Parser/InitializerNode.cc
===================================================================
--- translator/Parser/InitializerNode.cc	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/Parser/InitializerNode.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -9,95 +9,81 @@
 
 InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des )
-  : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 )
-{
-  if ( aggrp )
-    kids = dynamic_cast< InitializerNode *>( get_link() );
+	: expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ) {
+    if ( aggrp )
+	kids = dynamic_cast< InitializerNode *>( get_link() );
 
-  if ( kids != 0 )
-    set_link( 0 );
+    if ( kids != 0 )
+	set_link( 0 );
 }
 
 InitializerNode::InitializerNode( InitializerNode *init, bool aggrp, ExpressionNode *des )
-  : aggregate( aggrp ), designator( des ), kids( 0 )
-{
-  if (init != 0)
-    set_link(init);
+	: aggregate( aggrp ), designator( des ), kids( 0 ) {
+    if ( init != 0 )
+	set_link(init);
 
-  if ( aggrp )
-      kids = dynamic_cast< InitializerNode *>( get_link() );
+    if ( aggrp )
+	kids = dynamic_cast< InitializerNode *>( get_link() );
 
-  if ( kids != 0 )
-    set_next( 0 );
+    if ( kids != 0 )
+	set_next( 0 );
 }
 
 InitializerNode::~InitializerNode() {
-  delete expr;
+    delete expr;
 }
 
 void InitializerNode::print( std::ostream &os, int indent ) const {
-  os << std::string(indent, ' ') << "Initializer expression" << std::endl;
+    os << std::string(indent, ' ') << "Initializer expression" << std::endl;
 }
 
 void InitializerNode::printOneLine( std::ostream &os ) const {
-  if (!aggregate)
-    {
-
-      if ( designator != 0 )
-	{
-	  os << "designated by: (";
-	  ExpressionNode  *curdes = designator;
-	  while( curdes != 0){
-	    curdes->printOneLine(os);
-	    curdes = (ExpressionNode *)(curdes->get_link());
-	    if(curdes) os << ", ";
-	  }
-	  os << ")";
+    if ( ! aggregate ) {
+	if ( designator != 0 ) {
+	    os << "designated by: (";
+	    ExpressionNode  *curdes = designator;
+	    while( curdes != 0) {
+		curdes->printOneLine(os);
+		curdes = (ExpressionNode *)(curdes->get_link());
+		if ( curdes ) os << ", ";
+	    }
+	    os << ")";
 	}
-
-      if (expr) expr->printOneLine(os);
-    }
-  else  // It's an aggregate
-    {
-      os << "[--";
-      if( next_init() != 0 )
-	next_init()->printOneLine(os);
-
-      if (aggregate) os << "--]";
+	if ( expr ) expr->printOneLine(os);
+    } else {  // It's an aggregate
+	os << "[--";
+	if ( next_init() != 0 )
+	    next_init()->printOneLine(os);
+	if (aggregate) os << "--]";
     }
 
-  InitializerNode * moreInit;
-  if  ( get_link() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_link() ) ) != 0) )
-    moreInit->printOneLine( os );
+    InitializerNode *moreInit;
+    if  ( get_link() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_link() ) ) != 0) )
+	moreInit->printOneLine( os );
 }
 
 Initializer *InitializerNode::build() const {
-  // if ( get_expression() == 0 ) return 0;  // XXX (?)
+    // if ( get_expression() == 0 ) return 0;  // XXX (?)
 
-  if ( aggregate )
-    {
-      assert( next_init() != 0 );
+    if ( aggregate ) {
+	assert( next_init() != 0 );
 
-      std::list< Initializer *> initlist;
-      buildList<Initializer, InitializerNode>( next_init(), initlist );
+	std::list< Initializer *> initlist;
+	buildList<Initializer, InitializerNode>( next_init(), initlist );
 
-      std::list< Expression *> designlist;
-      if ( designator != 0 )
-	buildList<Expression, ExpressionNode>( designator, designlist );
+	std::list< Expression *> designlist;
+	if ( designator != 0 )
+	    buildList<Expression, ExpressionNode>( designator, designlist );
 
-      return new ListInit( initlist, designlist );
-    }
-  else
-    {
-      std::list< Expression *> designators;
+	return new ListInit( initlist, designlist );
+    } else {
+	std::list< Expression *> designators;
 
-      if ( designator != 0 )
-	buildList<Expression, ExpressionNode>( designator, designators );
+	if ( designator != 0 )
+	    buildList<Expression, ExpressionNode>( designator, designators );
 
-      if ( get_expression() != 0)
-	return new SingleInit( get_expression()->build(), designators );
+	if ( get_expression() != 0)
+	    return new SingleInit( get_expression()->build(), designators );
     }
 
-  return 0;
+    return 0;
 }
-
-
Index: translator/Parser/LinkageSpec.cc
===================================================================
--- translator/Parser/LinkageSpec.cc	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/Parser/LinkageSpec.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -1,9 +1,2 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: LinkageSpec.cc,v 1.3 2003/01/29 14:55:08 rcbilson Exp $
- *
- */
-
 #include <string>
 #include <cassert>
@@ -12,100 +5,74 @@
 #include "SemanticError.h"
 
-/* static class method */
-LinkageSpec::Type 
-LinkageSpec::fromString( const std::string &stringSpec )
-{
-  if( stringSpec == "\"Cforall\"" ) {
-    return Cforall;
-  } else if( stringSpec == "\"C\"" ) {
-    return C;
-  } else {
-    throw SemanticError( "Invalid linkage specifier " + stringSpec );
-  }
+LinkageSpec::Type LinkageSpec::fromString( const std::string &stringSpec ) {
+    if ( stringSpec == "\"Cforall\"" ) {
+	return Cforall;
+    } else if ( stringSpec == "\"C\"" ) {
+	return C;
+    } else {
+	throw SemanticError( "Invalid linkage specifier " + stringSpec );
+    }
 }
 
-/* static class method */
-std::string 
-LinkageSpec::toString( LinkageSpec::Type linkage )
-{
-  switch( linkage ) {
-  case Intrinsic:
-    return "intrinsic";
-    
-  case Cforall:
-    return "Cforall";
-    
-  case C:
-    return "C";
-    
-  case AutoGen:
-    return "automatically generated";
-    
-  case Compiler:
-    return "compiler built-in";
-  }
-  assert( false );
-  return "";
+std::string LinkageSpec::toString( LinkageSpec::Type linkage ) {
+    switch ( linkage ) {
+      case Intrinsic:
+	return "intrinsic";
+      case Cforall:
+	return "Cforall";
+      case C:
+	return "C";
+      case AutoGen:
+	return "automatically generated";
+      case Compiler:
+	return "compiler built-in";
+    }
+    assert( false );
+    return "";
 }
 
-/* static class method */
-bool 
-LinkageSpec::isDecoratable( Type t )
-{
-  switch( t ) {
-  case Intrinsic:
-  case Cforall:
-  case AutoGen:
-    return true;
-    
-  case C:
-  case Compiler:
+bool LinkageSpec::isDecoratable( Type t ) {
+    switch ( t ) {
+      case Intrinsic:
+      case Cforall:
+      case AutoGen:
+	return true;
+      case C:
+      case Compiler:
+	return false;
+    }
+    assert( false );
     return false;
-  }
-  assert( false );
-  return false;
 }
 
-/* static class method */
-bool 
-LinkageSpec::isGeneratable( Type t )
-{
-  switch( t ) {
-  case Intrinsic:
-  case Cforall:
-  case AutoGen:
-  case C:
-    return true;
-    
-  case Compiler:
+bool LinkageSpec::isGeneratable( Type t ) {
+    switch ( t ) {
+      case Intrinsic:
+      case Cforall:
+      case AutoGen:
+      case C:
+	return true;
+      case Compiler:
+	return false;
+    }
+    assert( false );
     return false;
-  }
-  assert( false );
-  return false;
 }
 
-/* static class method */
-bool 
-LinkageSpec::isOverloadable( Type t )
-{
-  return isDecoratable( t );
+bool LinkageSpec::isOverloadable( Type t ) {
+    return isDecoratable( t );
 }
 
-/* static class method */
-bool 
-LinkageSpec::isBuiltin( Type t )
-{
-  switch( t ) {
-  case Cforall:
-  case AutoGen:
-  case C:
+bool LinkageSpec::isBuiltin( Type t ) {
+    switch ( t ) {
+      case Cforall:
+      case AutoGen:
+      case C:
+	return false;
+      case Intrinsic:
+      case Compiler:
+	return true;
+    }
+    assert( false );
     return false;
-    
-  case Intrinsic:
-  case Compiler:
-    return true;
-  }
-  assert( false );
-  return false;
 }
-
Index: translator/Parser/LinkageSpec.h
===================================================================
--- translator/Parser/LinkageSpec.h	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/Parser/LinkageSpec.h	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -1,9 +1,2 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: LinkageSpec.h,v 1.3 2003/01/29 14:55:08 rcbilson Exp $
- *
- */
-
 #ifndef LINKAGESPEC_H
 #define LINKAGESPEC_H
@@ -11,23 +4,21 @@
 #include <string>
 
-struct LinkageSpec
-{
-  enum Type
-  {
-    Intrinsic,		// C built-in defined in prelude
-    Cforall,		// ordinary
-    C,			// not overloadable, not mangled
-    AutoGen,		// built by translator (struct assignment)
-    Compiler		// gcc internal
-  };
+struct LinkageSpec {
+    enum Type {
+	Intrinsic,		// C built-in defined in prelude
+	Cforall,		// ordinary
+	C,			// not overloadable, not mangled
+	AutoGen,		// built by translator (struct assignment)
+	Compiler		// gcc internal
+    };
   
-  static Type fromString( const std::string& );
-  static std::string toString( Type );
+    static Type fromString( const std::string & );
+    static std::string toString( Type );
   
-  static bool isDecoratable( Type );
-  static bool isGeneratable( Type );
-  static bool isOverloadable( Type );
-  static bool isBuiltin( Type );
+    static bool isDecoratable( Type );
+    static bool isGeneratable( Type );
+    static bool isOverloadable( Type );
+    static bool isBuiltin( Type );
 };
 
-#endif /* #ifndef LINKAGESPEC_H */
+#endif // LINKAGESPEC_H
Index: translator/Parser/ParseNode.cc
===================================================================
--- translator/Parser/ParseNode.cc	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/Parser/ParseNode.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -1,3 +1,2 @@
-/* -*- C++ -*- */
 #include "ParseNode.h"
 using namespace std;
@@ -6,84 +5,79 @@
 int ParseNode::indent_by = 4;
 
-ParseNode::ParseNode(void): next( 0 ) {};
-ParseNode::ParseNode (string _name) : name(_name), next( 0 ) {}
+ParseNode::ParseNode( void ) : next( 0 ) {};
+ParseNode::ParseNode( string _name ) : name( _name ), next( 0 ) {}
 
-ParseNode *ParseNode::set_name (string _name) {
-  name = _name;
-
-  return this;
+ParseNode *ParseNode::set_name( string _name ) {
+    name = _name;
+    return this;
 }
 
-ParseNode *ParseNode::set_name (string *_name) {
-  name = *_name; // deep copy
-  delete _name;
+ParseNode *ParseNode::set_name( string *_name ) {
+    name = *_name; // deep copy
+    delete _name;
 
-  return this;
+    return this;
 }
 
-ParseNode::~ParseNode(void){
-  delete next;
+ParseNode::~ParseNode( void ) {
+    delete next;
 };
 
-string ParseNode::get_name(void) {
-  return name;
+string ParseNode::get_name( void ) {
+    return name;
 }
 
-ParseNode *ParseNode::get_link(void) const {
-  return next;
+ParseNode *ParseNode::get_link( void ) const {
+    return next;
 }
 
 ParseNode *ParseNode::get_last(void) {
-  ParseNode * current = this;
+    ParseNode *current = this;
 
-  while(current->get_link() != 0)
-    current = current->get_link();
+    while( current->get_link() != 0 )
+	current = current->get_link();
 
-  return current;
+    return current;
 }
 
 ParseNode *ParseNode::set_link(ParseNode *_next){
-  ParseNode *follow;
+    ParseNode *follow;
 
-  if(_next == 0) return this;
+    if ( _next == 0 ) return this;
 
-  for(follow = this; follow->next != 0; follow = follow->next);
-  follow->next = _next;
+    for ( follow = this; follow->next != 0; follow = follow->next );
+    follow->next = _next;
 
-  return this;
+    return this;
 }
 
 const string ParseNode::get_name(void) const {
-  return name;
+    return name;
 }
 
-void ParseNode::print(std::ostream &os, int indent) const
-{
+void ParseNode::print(std::ostream &os, int indent) const {}
+
+
+void ParseNode::printList( std::ostream &os, int indent ) const {
+    print( os, indent );
+
+    if ( next ) {
+	next->printList( os, indent );
+    }
 }
 
+ParseNode &ParseNode::operator,( ParseNode &p ) {
+    set_link( &p );
 
-void ParseNode::printList(std::ostream &os, int indent) const
-{
-  print( os, indent );
-
-  if( next ) {
-    next->printList( os, indent );
-  }
-}
-
-ParseNode &ParseNode::operator,(ParseNode &p){
-  set_link(&p);
-
-  return *this;
+    return *this;
 }
 
 ParseNode *mkList(ParseNode &pn){
-  /* it just relies on `operator,' to take care of the "arguments" and provides
-     a nice interface to an awful-looking address-of, rendering, for example
-         (StatementNode *)(&(*$5 + *$7)) into (StatementNode *)mkList(($5, $7))
-     (although "nice"  is probably not the word)
-  */
-
-  return &pn;
+    /* it just relies on `operator,' to take care of the "arguments" and provides
+       a nice interface to an awful-looking address-of, rendering, for example
+       (StatementNode *)(&(*$5 + *$7)) into (StatementNode *)mkList(($5, $7))
+       (although "nice"  is probably not the word)
+    */
+    return &pn;
 }
 
Index: translator/Parser/cfa.y
===================================================================
--- translator/Parser/cfa.y	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/Parser/cfa.y	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -10,6 +10,6 @@
  * Created On       : Sat Sep  1 20:22:55 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Sun Nov  9 22:45:42 2014
- * Update Count     : 881
+ * Last Modified On : Tue Nov 25 23:52:54 2014
+ * Update Count     : 890
  */
 
@@ -563,5 +563,5 @@
 	| tuple assignment_opt				/* CFA, tuple expression */
 		{
-		  if( $2 == 0 ) {
+		  if ( $2 == 0 ) {
 		    $$ = $1;
 		  } else {
@@ -654,5 +654,5 @@
 	block_item
 	| block_item_list push block_item
-		{ if($1 != 0) { $1->set_link($3); $$ = $1; } }
+		{ if ($1 != 0) { $1->set_link($3); $$ = $1; } }
 	;
 
@@ -668,5 +668,5 @@
 	statement
 	| statement_list statement
-		{ if($1 != 0) { $1->set_link($2); $$ = $1; } }
+		{ if ($1 != 0) { $1->set_link($2); $$ = $1; } }
 	;
 
@@ -1870,5 +1870,5 @@
 	| external_definition_list
 		{
-		  if( theTree ) {
+		  if ( theTree ) {
 		    theTree->appendList( $1 );
 		  } else {
@@ -1882,5 +1882,5 @@
 	| external_definition_list push external_definition
 		{
-		  if( $1 ) {
+		  if ( $1 ) {
 		    $$ = $1->appendList( $3 );
 		  } else {
@@ -2732,11 +2732,12 @@
 /* ----end of grammar----*/
 
-void yyerror(char *string) {
+void yyerror( char *string ) {
     using std::cout;
     using std::endl;
-    if( yyfilename ) {
-      cout << yyfilename << ":" << endl;
+    cout << "Error ";
+    if ( yyfilename ) {
+	cout << "in file " << yyfilename << " ";
     }
-    cout << yylineno << ": syntax error reading token " << *(yylval.tok.str) << endl;
+    cout << "at line " << yylineno << " reading token \"" << *(yylval.tok.str) << "\"" << endl;
 }
 
Index: translator/Parser/lex.l
===================================================================
--- translator/Parser/lex.l	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/Parser/lex.l	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -10,6 +10,6 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Tue Nov 11 08:10:05 2014
- * Update Count     : 215
+ * Last Modified On : Wed Dec  3 13:37:52 2014
+ * Update Count     : 317
  */
 
@@ -31,4 +31,5 @@
 
 char *yyfilename;
+std::string *strtext;					// accumulate parts of character and string constant value
 
 #define WHITE_RETURN(x)					// do nothing
@@ -38,4 +39,8 @@
                                 yylval.tok.loc.line = yylineno; \
                                 return(x)
+#define RETURN_STR(x)		yylval.tok.str = strtext; \
+                                yylval.tok.loc.file = yyfilename; \
+                                yylval.tok.loc.line = yylineno; \
+                                return(x)
 
 #define KEYWORD_RETURN(x)	RETURN_VAL(x)		// keyword
@@ -49,7 +54,8 @@
 #define NUMERIC_RETURN(x)	rm_underscore(); RETURN_VAL(x) // numeric constant
 
-void rm_underscore() {					// remove underscores in constant or escape sequence
+void rm_underscore() {
+    // remove underscores in numeric constant
     int j = 0;
-    for ( int i = 0; i < yyleng; i += 1 ) {
+    for ( int i = 0; yytext[i] != '\0'; i += 1 ) {
 	if ( yytext[i] != '_' ) {
 	    yytext[j] = yytext[i];
@@ -67,5 +73,5 @@
 decimal [0-9]
 hex [0-9a-fA-F]
-universal_char "\\"((u{hex_quad})|(U{hex_quad}{2}))
+universal_char "\\"((u"_"?{hex_quad})|(U"_"?{hex_quad}{2}))
 
 	// identifier, GCC: $ in identifier
@@ -79,5 +85,5 @@
 
 	// numeric constants, CFA: '_' in constant
-hex_quad {hex}{4}
+hex_quad {hex}("_"?{hex}){3}
 integer_suffix "_"?(([uU][lL]?)|([uU]("ll"|"LL")?)|([lL][uU]?)|("ll"|"LL")[uU]?)
 
@@ -106,6 +112,6 @@
 simple_escape "\\"[abefnrtv'"?\\]
 	// ' stop highlighting
-octal_escape "\\"{octal}{1,3}
-hex_escape "\\""x"{hex}+
+octal_escape "\\"{octal}("_"?{octal}){0,2}
+hex_escape "\\""x""_"?{hex_digits}
 escape_seq {simple_escape}|{octal_escape}|{hex_escape}|{universal_char}
 
@@ -129,5 +135,7 @@
 
 %x COMMENT
-%x QUOTED
+%x BKQUOTE
+%x QUOTE
+%x STRING
 
 %%
@@ -141,15 +149,15 @@
 	lineno = strtol( yytext + 1, &end_num, 0 );
 	begin_string = strchr( end_num, '"' );
-	if( begin_string ) {
-	  end_string = strchr( begin_string + 1, '"' );
-	  if( end_string ) {
-	    length = end_string - begin_string - 1;
-	    filename = new char[ length + 1 ];
-	    memcpy( filename, begin_string + 1, length );
-	    filename[ length ] = '\0';
-	    //std::cout << "file " << filename << " line " << lineno << std::endl;
-	    yylineno = lineno;
-	    yyfilename = filename;
-	  }
+	if ( begin_string ) {
+	    end_string = strchr( begin_string + 1, '"' );
+	    if ( end_string ) {
+		length = end_string - begin_string - 1;
+		filename = new char[ length + 1 ];
+		memcpy( filename, begin_string + 1, length );
+		filename[ length ] = '\0';
+		//std::cout << "file " << filename << " line " << lineno << std::endl;
+		yylineno = lineno;
+		yyfilename = filename;
+	    }
 	}
 }
@@ -159,7 +167,7 @@
 
 	/* ignore C style comments */
-"/*"			{BEGIN COMMENT;}
+"/*"			{ BEGIN COMMENT; }
 <COMMENT>.|\n		;
-<COMMENT>"*/"		{BEGIN 0;}
+<COMMENT>"*/"		{ BEGIN 0; }
 
 	/* ignore C++ style comments */
@@ -167,171 +175,178 @@
 
 	/* ignore whitespace */
-{h_white}+		{WHITE_RETURN(' ');}
-({v_tab}|{c_return}|{form_feed})+ {WHITE_RETURN(' ');}
-({h_white}|{v_tab}|{c_return}|{form_feed})*"\n" {NEWLINE_RETURN();}
+{h_white}+		{ WHITE_RETURN(' '); }
+({v_tab}|{c_return}|{form_feed})+ { WHITE_RETURN(' '); }
+({h_white}|{v_tab}|{c_return}|{form_feed})*"\n" { NEWLINE_RETURN(); }
 
 	/* keywords */
-__alignof		{KEYWORD_RETURN(ALIGNOF);}	/* GCC */
-__alignof__		{KEYWORD_RETURN(ALIGNOF);}	/* GCC */
-asm			{KEYWORD_RETURN(ASM);}
-__asm			{KEYWORD_RETURN(ASM);}		/* GCC */
-__asm__			{KEYWORD_RETURN(ASM);}		/* GCC */
-__attribute		{KEYWORD_RETURN(ATTRIBUTE);}	/* GCC */
-__attribute__		{KEYWORD_RETURN(ATTRIBUTE);}	/* GCC */
-auto			{KEYWORD_RETURN(AUTO);}
-_Bool			{KEYWORD_RETURN(BOOL);}		/* ANSI99 */
-break			{KEYWORD_RETURN(BREAK);}
-case			{KEYWORD_RETURN(CASE);}
-catch			{KEYWORD_RETURN(CATCH);}	/* CFA */
-char			{KEYWORD_RETURN(CHAR);}
-choose			{KEYWORD_RETURN(CHOOSE);}	/* CFA */
-_Complex		{KEYWORD_RETURN(COMPLEX);}	/* ANSI99 */
-__complex		{KEYWORD_RETURN(COMPLEX);}	/* GCC */
-__complex__		{KEYWORD_RETURN(COMPLEX);}	/* GCC */
-const			{KEYWORD_RETURN(CONST);}
-__const			{KEYWORD_RETURN(CONST);}	/* GCC */
-__const__		{KEYWORD_RETURN(CONST);}	/* GCC */
-context			{KEYWORD_RETURN(CONTEXT);}	/* CFA */
-continue		{KEYWORD_RETURN(CONTINUE);}
-default			{KEYWORD_RETURN(DEFAULT);}
-do			{KEYWORD_RETURN(DO);}
-double			{KEYWORD_RETURN(DOUBLE);}
-dtype			{KEYWORD_RETURN(DTYPE);}	/* CFA */
-else			{KEYWORD_RETURN(ELSE);}
-enum			{KEYWORD_RETURN(ENUM);}
-__extension__		{KEYWORD_RETURN(EXTENSION);}	/* GCC */
-extern			{KEYWORD_RETURN(EXTERN);}
-fallthru		{KEYWORD_RETURN(FALLTHRU);}	/* CFA */
-finally			{KEYWORD_RETURN(FINALLY);}	/* CFA */
-float			{KEYWORD_RETURN(FLOAT);}
-for			{KEYWORD_RETURN(FOR);}
-forall			{KEYWORD_RETURN(FORALL);}	/* CFA */
-fortran			{KEYWORD_RETURN(FORTRAN);}
-ftype			{KEYWORD_RETURN(FTYPE);}	/* CFA */
-goto			{KEYWORD_RETURN(GOTO);}
-if			{KEYWORD_RETURN(IF);}
-_Imaginary		{KEYWORD_RETURN(IMAGINARY);}	/* ANSI99 */
-__imag			{KEYWORD_RETURN(IMAGINARY);}	/* GCC */
-__imag__		{KEYWORD_RETURN(IMAGINARY);}	/* GCC */
-inline			{KEYWORD_RETURN(INLINE);}	/* ANSI99 */
-__inline		{KEYWORD_RETURN(INLINE);}	/* GCC */
-__inline__		{KEYWORD_RETURN(INLINE);}	/* GCC */
-int			{KEYWORD_RETURN(INT);}
-__label__		{KEYWORD_RETURN(LABEL);}	/* GCC */
-long			{KEYWORD_RETURN(LONG);}
-lvalue			{KEYWORD_RETURN(LVALUE);}	/* CFA */
-register		{KEYWORD_RETURN(REGISTER);}
-restrict		{KEYWORD_RETURN(RESTRICT);}	/* ANSI99 */
-__restrict		{KEYWORD_RETURN(RESTRICT);}	/* GCC */
-__restrict__		{KEYWORD_RETURN(RESTRICT);}	/* GCC */
-return			{KEYWORD_RETURN(RETURN);}
-short			{KEYWORD_RETURN(SHORT);}
-signed			{KEYWORD_RETURN(SIGNED);}
-__signed		{KEYWORD_RETURN(SIGNED);}	/* GCC */
-__signed__		{KEYWORD_RETURN(SIGNED);}	/* GCC */
-sizeof			{KEYWORD_RETURN(SIZEOF);}
-static			{KEYWORD_RETURN(STATIC);}
-struct			{KEYWORD_RETURN(STRUCT);}
-switch			{KEYWORD_RETURN(SWITCH);}
-throw			{KEYWORD_RETURN(THROW);}	/* CFA */
-try			{KEYWORD_RETURN(TRY);}		/* CFA */
-type			{KEYWORD_RETURN(TYPE);}		/* CFA */
-typedef			{KEYWORD_RETURN(TYPEDEF);}
-typeof			{KEYWORD_RETURN(TYPEOF);}	/* GCC */
-__typeof		{KEYWORD_RETURN(TYPEOF);}	/* GCC */
-__typeof__		{KEYWORD_RETURN(TYPEOF);}	/* GCC */
-union			{KEYWORD_RETURN(UNION);}
-unsigned		{KEYWORD_RETURN(UNSIGNED);}
-void			{KEYWORD_RETURN(VOID);}
-volatile		{KEYWORD_RETURN(VOLATILE);}
-__volatile		{KEYWORD_RETURN(VOLATILE);}	/* GCC */
-__volatile__		{KEYWORD_RETURN(VOLATILE);}	/* GCC */
-while			{KEYWORD_RETURN(WHILE);}
+__alignof		{ KEYWORD_RETURN(ALIGNOF); }	// GCC
+__alignof__		{ KEYWORD_RETURN(ALIGNOF); }	// GCC
+asm			{ KEYWORD_RETURN(ASM); }
+__asm			{ KEYWORD_RETURN(ASM); }	// GCC
+__asm__			{ KEYWORD_RETURN(ASM); }	// GCC
+__attribute		{ KEYWORD_RETURN(ATTRIBUTE); }	// GCC
+__attribute__		{ KEYWORD_RETURN(ATTRIBUTE); }	// GCC
+auto			{ KEYWORD_RETURN(AUTO); }
+_Bool			{ KEYWORD_RETURN(BOOL); }	// C99
+break			{ KEYWORD_RETURN(BREAK); }
+case			{ KEYWORD_RETURN(CASE); }
+catch			{ KEYWORD_RETURN(CATCH); }	// CFA
+char			{ KEYWORD_RETURN(CHAR); }
+choose			{ KEYWORD_RETURN(CHOOSE); }	// CFA
+_Complex		{ KEYWORD_RETURN(COMPLEX); }	// C99
+__complex		{ KEYWORD_RETURN(COMPLEX); }	// GCC
+__complex__		{ KEYWORD_RETURN(COMPLEX); }	// GCC
+const			{ KEYWORD_RETURN(CONST); }
+__const			{ KEYWORD_RETURN(CONST); }	// GCC
+__const__		{ KEYWORD_RETURN(CONST); }	// GCC
+context			{ KEYWORD_RETURN(CONTEXT); }	// CFA
+continue		{ KEYWORD_RETURN(CONTINUE); }
+default			{ KEYWORD_RETURN(DEFAULT); }
+do			{ KEYWORD_RETURN(DO); }
+double			{ KEYWORD_RETURN(DOUBLE); }
+dtype			{ KEYWORD_RETURN(DTYPE); }	// CFA
+else			{ KEYWORD_RETURN(ELSE); }
+enum			{ KEYWORD_RETURN(ENUM); }
+__extension__		{ KEYWORD_RETURN(EXTENSION); }	// GCC
+extern			{ KEYWORD_RETURN(EXTERN); }
+fallthru		{ KEYWORD_RETURN(FALLTHRU); }	// CFA
+finally			{ KEYWORD_RETURN(FINALLY); }	// CFA
+float			{ KEYWORD_RETURN(FLOAT); }
+for			{ KEYWORD_RETURN(FOR); }
+forall			{ KEYWORD_RETURN(FORALL); }	// CFA
+fortran			{ KEYWORD_RETURN(FORTRAN); }
+ftype			{ KEYWORD_RETURN(FTYPE); }	// CFA
+goto			{ KEYWORD_RETURN(GOTO); }
+if			{ KEYWORD_RETURN(IF); }
+_Imaginary		{ KEYWORD_RETURN(IMAGINARY); }	// C99
+__imag			{ KEYWORD_RETURN(IMAGINARY); }	// GCC
+__imag__		{ KEYWORD_RETURN(IMAGINARY); }	// GCC
+inline			{ KEYWORD_RETURN(INLINE); }	// C99
+__inline		{ KEYWORD_RETURN(INLINE); }	// GCC
+__inline__		{ KEYWORD_RETURN(INLINE); }	// GCC
+int			{ KEYWORD_RETURN(INT); }
+__label__		{ KEYWORD_RETURN(LABEL); }	// GCC
+long			{ KEYWORD_RETURN(LONG); }
+lvalue			{ KEYWORD_RETURN(LVALUE); }	// CFA
+register		{ KEYWORD_RETURN(REGISTER); }
+restrict		{ KEYWORD_RETURN(RESTRICT); }	// C99
+__restrict		{ KEYWORD_RETURN(RESTRICT); }	// GCC
+__restrict__		{ KEYWORD_RETURN(RESTRICT); }	// GCC
+return			{ KEYWORD_RETURN(RETURN); }
+short			{ KEYWORD_RETURN(SHORT); }
+signed			{ KEYWORD_RETURN(SIGNED); }
+__signed		{ KEYWORD_RETURN(SIGNED); }	// GCC
+__signed__		{ KEYWORD_RETURN(SIGNED); }	// GCC
+sizeof			{ KEYWORD_RETURN(SIZEOF); }
+static			{ KEYWORD_RETURN(STATIC); }
+struct			{ KEYWORD_RETURN(STRUCT); }
+switch			{ KEYWORD_RETURN(SWITCH); }
+throw			{ KEYWORD_RETURN(THROW); }	// CFA
+try			{ KEYWORD_RETURN(TRY); }	// CFA
+type			{ KEYWORD_RETURN(TYPE); }	// CFA
+typedef			{ KEYWORD_RETURN(TYPEDEF); }
+typeof			{ KEYWORD_RETURN(TYPEOF); }	// GCC
+__typeof		{ KEYWORD_RETURN(TYPEOF); }	// GCC
+__typeof__		{ KEYWORD_RETURN(TYPEOF); }	// GCC
+union			{ KEYWORD_RETURN(UNION); }
+unsigned		{ KEYWORD_RETURN(UNSIGNED); }
+void			{ KEYWORD_RETURN(VOID); }
+volatile		{ KEYWORD_RETURN(VOLATILE); }
+__volatile		{ KEYWORD_RETURN(VOLATILE); }	// GCC
+__volatile__		{ KEYWORD_RETURN(VOLATILE); }	// GCC
+while			{ KEYWORD_RETURN(WHILE); }
 
 	/* identifier */
-{identifier}		{IDENTIFIER_RETURN();}
-{attr_identifier}	{ATTRIBUTE_RETURN();}
-"`"			{BEGIN QUOTED;}
-<QUOTED>{identifier}	{IDENTIFIER_RETURN();}
-<QUOTED>"`"		{BEGIN 0;}
+{identifier}		{ IDENTIFIER_RETURN(); }
+{attr_identifier}	{ ATTRIBUTE_RETURN(); }
+"`"			{ BEGIN BKQUOTE; }
+<BKQUOTE>{identifier}	{ IDENTIFIER_RETURN(); }
+<BKQUOTE>"`"		{ BEGIN 0; }
 
 	/* numeric constants */
-"0"			{NUMERIC_RETURN(ZERO);}		/* CFA */
-"1"			{NUMERIC_RETURN(ONE);}		/* CFA */
-{decimal_constant}	{NUMERIC_RETURN(INTEGERconstant);}
-{octal_constant}	{NUMERIC_RETURN(INTEGERconstant);}
-{hex_constant}		{NUMERIC_RETURN(INTEGERconstant);}
-{floating_constant}	{NUMERIC_RETURN(FLOATINGconstant);}
-{hex_floating_constant}	{NUMERIC_RETURN(FLOATINGconstant);}
+"0"			{ NUMERIC_RETURN(ZERO); }	// CFA
+"1"			{ NUMERIC_RETURN(ONE); }	// CFA
+{decimal_constant}	{ NUMERIC_RETURN(INTEGERconstant); }
+{octal_constant}	{ NUMERIC_RETURN(INTEGERconstant); }
+{hex_constant}		{ NUMERIC_RETURN(INTEGERconstant); }
+{floating_constant}	{ NUMERIC_RETURN(FLOATINGconstant); }
+{hex_floating_constant}	{ NUMERIC_RETURN(FLOATINGconstant); }
 
 	/* character constant, allows empty value */
-"L"?[']([^'\\\n]|{escape_seq})*['] {RETURN_VAL(CHARACTERconstant);}
+"L"?"_"?[']		{ BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
+<QUOTE>[^'\\\n]*	{ *strtext += std::string( yytext ); }
+<QUOTE>['\n]		{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
 	/* ' stop highlighting */
 
 	/* string constant */
-"L"?["]([^"\\\n]|{escape_seq})*["] {RETURN_VAL(STRINGliteral);}
+"L"?"_"?["]		{ BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
+<STRING>[^"\\\n]*	{ *strtext += std::string( yytext ); }
+<STRING>["\n]		{ BEGIN 0; *strtext += std::string( yytext); RETURN_STR(STRINGliteral); }
 	/* " stop highlighting */
 
+<QUOTE,STRING>{escape_seq} { rm_underscore(); *strtext += std::string( yytext ); }
+<QUOTE,STRING>[\\]	{ *strtext += std::string( yytext ); } // unknown escape character
+
 	/* punctuation */
-"["			{ASCIIOP_RETURN();}
-"]"			{ASCIIOP_RETURN();}
-"("			{ASCIIOP_RETURN();}
-")"			{ASCIIOP_RETURN();}
-"{"			{ASCIIOP_RETURN();}
-"}"			{ASCIIOP_RETURN();}
-","			{ASCIIOP_RETURN();}		/* also operator */
-":"			{ASCIIOP_RETURN();}
-";"			{ASCIIOP_RETURN();}
-"."			{ASCIIOP_RETURN();}		/* also operator */
-"..."			{NAMEDOP_RETURN(ELLIPSIS);}
-
-	/* alternative ANSI99 brackets, "<:" & "<:<:" handled by preprocessor */
-"<:"			{RETURN_VAL('[');}
-":>"			{RETURN_VAL(']');}
-"<%"			{RETURN_VAL('{');}
-"%>"			{RETURN_VAL('}');}
+"["			{ ASCIIOP_RETURN(); }
+"]"			{ ASCIIOP_RETURN(); }
+"("			{ ASCIIOP_RETURN(); }
+")"			{ ASCIIOP_RETURN(); }
+"{"			{ ASCIIOP_RETURN(); }
+"}"			{ ASCIIOP_RETURN(); }
+","			{ ASCIIOP_RETURN(); }		// also operator
+":"			{ ASCIIOP_RETURN(); }
+";"			{ ASCIIOP_RETURN(); }
+"."			{ ASCIIOP_RETURN(); }		// also operator
+"..."			{ NAMEDOP_RETURN(ELLIPSIS); }
+
+	/* alternative C99 brackets, "<:" & "<:<:" handled by preprocessor */
+"<:"			{ RETURN_VAL('['); }
+":>"			{ RETURN_VAL(']'); }
+"<%"			{ RETURN_VAL('{'); }
+"%>"			{ RETURN_VAL('}'); }
 
 	/* operators */
-"!"			{ASCIIOP_RETURN();}
-"+"			{ASCIIOP_RETURN();}
-"-"			{ASCIIOP_RETURN();}
-"*"			{ASCIIOP_RETURN();}
-"/"			{ASCIIOP_RETURN();}
-"%"			{ASCIIOP_RETURN();}
-"^"			{ASCIIOP_RETURN();}
-"~"			{ASCIIOP_RETURN();}
-"&"			{ASCIIOP_RETURN();}
-"|"			{ASCIIOP_RETURN();}
-"<"			{ASCIIOP_RETURN();}
-">"			{ASCIIOP_RETURN();}
-"="			{ASCIIOP_RETURN();}
-"?"			{ASCIIOP_RETURN();}
-
-"++"			{NAMEDOP_RETURN(ICR);}
-"--"			{NAMEDOP_RETURN(DECR);}
-"=="			{NAMEDOP_RETURN(EQ);}
-"!="			{NAMEDOP_RETURN(NE);}
-"<<"			{NAMEDOP_RETURN(LS);}
-">>"			{NAMEDOP_RETURN(RS);}
-"<="			{NAMEDOP_RETURN(LE);}
-">="			{NAMEDOP_RETURN(GE);}
-"&&"			{NAMEDOP_RETURN(ANDAND);}
-"||"			{NAMEDOP_RETURN(OROR);}
-"->"			{NAMEDOP_RETURN(ARROW);}
-"+="			{NAMEDOP_RETURN(PLUSassign);}
-"-="			{NAMEDOP_RETURN(MINUSassign);}
-"*="			{NAMEDOP_RETURN(MULTassign);}
-"/="			{NAMEDOP_RETURN(DIVassign);}
-"%="			{NAMEDOP_RETURN(MODassign);}
-"&="			{NAMEDOP_RETURN(ANDassign);}
-"|="			{NAMEDOP_RETURN(ORassign);}
-"^="			{NAMEDOP_RETURN(ERassign);}
-"<<="			{NAMEDOP_RETURN(LSassign);}
-">>="			{NAMEDOP_RETURN(RSassign);}
+"!"			{ ASCIIOP_RETURN(); }
+"+"			{ ASCIIOP_RETURN(); }
+"-"			{ ASCIIOP_RETURN(); }
+"*"			{ ASCIIOP_RETURN(); }
+"/"			{ ASCIIOP_RETURN(); }
+"%"			{ ASCIIOP_RETURN(); }
+"^"			{ ASCIIOP_RETURN(); }
+"~"			{ ASCIIOP_RETURN(); }
+"&"			{ ASCIIOP_RETURN(); }
+"|"			{ ASCIIOP_RETURN(); }
+"<"			{ ASCIIOP_RETURN(); }
+">"			{ ASCIIOP_RETURN(); }
+"="			{ ASCIIOP_RETURN(); }
+"?"			{ ASCIIOP_RETURN(); }
+
+"++"			{ NAMEDOP_RETURN(ICR); }
+"--"			{ NAMEDOP_RETURN(DECR); }
+"=="			{ NAMEDOP_RETURN(EQ); }
+"!="			{ NAMEDOP_RETURN(NE); }
+"<<"			{ NAMEDOP_RETURN(LS); }
+">>"			{ NAMEDOP_RETURN(RS); }
+"<="			{ NAMEDOP_RETURN(LE); }
+">="			{ NAMEDOP_RETURN(GE); }
+"&&"			{ NAMEDOP_RETURN(ANDAND); }
+"||"			{ NAMEDOP_RETURN(OROR); }
+"->"			{ NAMEDOP_RETURN(ARROW); }
+"+="			{ NAMEDOP_RETURN(PLUSassign); }
+"-="			{ NAMEDOP_RETURN(MINUSassign); }
+"*="			{ NAMEDOP_RETURN(MULTassign); }
+"/="			{ NAMEDOP_RETURN(DIVassign); }
+"%="			{ NAMEDOP_RETURN(MODassign); }
+"&="			{ NAMEDOP_RETURN(ANDassign); }
+"|="			{ NAMEDOP_RETURN(ORassign); }
+"^="			{ NAMEDOP_RETURN(ERassign); }
+"<<="			{ NAMEDOP_RETURN(LSassign); }
+">>="			{ NAMEDOP_RETURN(RSassign); }
 
 	/* CFA, operator identifier */
-{op_unary}"?"		{IDENTIFIER_RETURN();}		/* unary */
-"?"({op_unary_pre_post}|"()"|"[?]") {IDENTIFIER_RETURN();}
-"?"{op_binary_over}"?"	{IDENTIFIER_RETURN();}		/* binary */
+{op_unary}"?"		{ IDENTIFIER_RETURN(); }	// unary
+"?"({op_unary_pre_post}|"()"|"[?]") { IDENTIFIER_RETURN(); }
+"?"{op_binary_over}"?"	{ IDENTIFIER_RETURN(); }	// binary
 	/*
 	  This rule handles ambiguous cases with operator identifiers, e.g., "int *?*?()", where the
@@ -365,5 +380,5 @@
 			    // 1 or 2 character unary operator ?
 			    int i = yytext[1] == '?' ? 1 : 2;
-			    yyless( i );		/* put back characters up to first '?' */
+			    yyless( i );		// put back characters up to first '?'
 			    if ( i > 1 ) {
 				NAMEDOP_RETURN( yytext[0] == '+' ? ICR : DECR );
@@ -374,5 +389,5 @@
 
 	/* unknown characters */
-.			{printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno);}
+.			{ printf("unknown character(s):\"%s\" on line %d\n", yytext, yylineno); }
 
 %%
Index: translator/SynTree/Initializer.cc
===================================================================
--- translator/SynTree/Initializer.cc	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/SynTree/Initializer.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -31,5 +31,5 @@
 }
 
-SingleInit::SingleInit ( Expression *v, std::list< Expression *> &_designators )
+SingleInit::SingleInit( Expression *v, std::list< Expression *> &_designators )
     : value ( v ), designators( _designators )
 { 
@@ -111,3 +111,2 @@
 	(*i)->print( os, indent + 2 );
 }
-
Index: translator/SynTree/Visitor.h
===================================================================
--- translator/SynTree/Visitor.h	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/SynTree/Visitor.h	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -110,5 +110,5 @@
 {
     SemanticError errors;
-    for( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
+   for( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
 	try {
 	    if( *i ) {
Index: translator/Tests/Syntax/CharStringConstants.c
===================================================================
--- translator/Tests/Syntax/CharStringConstants.c	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/Tests/Syntax/CharStringConstants.c	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -16,9 +16,10 @@
     '\v';
     '\'';
-    '\"'; //"
+    '\"';
     '\?';
     '\\';
 
     '\0';				// octal escape
+
     '\377';
 
@@ -73,10 +74,14 @@
     "_\xff_";
     "\xf_f";
-    "\xff_ff";
 
 // warnings/errors
 
+    "\xff_ff";
     "\xfff";				// hex escape out of range
     "a\xff34w";
     "\xffff";
 }
+
+// Local Variables: //
+// compile-command: "../../../bin/cfa -std=c99 CharStringConstants.c" //
+// End: //
Index: translator/Tests/Syntax/NumericConstants.c
===================================================================
--- translator/Tests/Syntax/NumericConstants.c	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/Tests/Syntax/NumericConstants.c	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -49,2 +49,6 @@
     0x_1.ffff_ffff_p_128_l;
 }
+
+// Local Variables: //
+// compile-command: "../../../bin/cfa -std=c99 NumericConstants.c" //
+// End: //
Index: anslator/examples/loopbreak.c
===================================================================
--- translator/examples/loopbreak.c	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ 	(revision )
@@ -1,39 +1,0 @@
-int main() {
-  L1: {
-	double d = 12.123_333_E27;
-      L2: switch ( 3_333_333 ) {	// underscores in constant
-	  case 1,2,3:			// 4~8, 4...8 not working
-	  L3: for ( ;; ) {
-	      L4: for ( ;; ) {
-		    break L1;		// labelled break
-		    break L2;
-		    break L3;
-		    break L4;
-#if 1
-		    continue L1;	// labelled continue
-		    continue L2;
-		    continue L3;
-		    continue L4;
-#endif
-		} // for
-	    } // for
-	    break;
-	  default:
-	    break L1;
-	} // switch
-	3;
-	int i, j;
-	choose ( 7 ) {
-	  case 1,2,3:
-	    i = 3;
-	    fallthru;
-	  case 4,5,6:
-	    j = 3;
-	  default: ;
-	} // choose
-    } // block
-} // main
-
-// Local Variables: //
-// compile-command: "../../bin/cfa loopbreak.c" //
-// End: //
Index: translator/examples/min.c
===================================================================
--- translator/examples/min.c	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/examples/min.c	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -4,12 +4,12 @@
 
 forall( type T | { int ?<?( T, T ); } )
-T min( T t1, T t2 ) {
+T min( const T t1, const T t2 ) {
     return t1 < t2 ? t1 : t2;
 }
 
 int main() {
-//    char c;
-//    c = min( 'a', 'z' );
-//    printf( "minimum %d\n", c );
+    char c;
+    c = min( 'a', 'z' );
+    printf( "minimum %d\n", c );
     int i;
     i = min( 4, 3 );
Index: translator/main.cc
===================================================================
--- translator/main.cc	(revision 42dcae7185b7830fd591cd47f895c0a362a6e77d)
+++ translator/main.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
@@ -232,17 +232,25 @@
 	}
 
+	std::cerr << "before validate" << std::endl;
 	SymTab::validate( translationUnit, false );
 	//Try::visit( translationUnit );
 	//Tuples::mutate( translationUnit );
 	//InitTweak::mutate( translationUnit );
+	std::cerr << "before mutate" << std::endl;
 	ControlStruct::mutate( translationUnit );
+	std::cerr << "before fixNames" << std::endl;
 	CodeGen::fixNames( translationUnit );
+	std::cerr << "before resolve" << std::endl;
 	ResolvExpr::resolve( translationUnit );
 	//Tuples::checkFunctions( translationUnit );
 	//      std::cerr << "Finished tuple checkfunctions" << std::endl;
 	//printAll( translationUnit, std::cerr );
+	std::cerr << "before copyParams" << std::endl;
 	GenPoly::copyParams( translationUnit );
+	std::cerr << "before convertSpecializations" << std::endl;
 	GenPoly::convertSpecializations( translationUnit );
+	std::cerr << "before convertLvalue" << std::endl;
 	GenPoly::convertLvalue( translationUnit );
+	std::cerr << "before box" << std::endl;
 	GenPoly::box( translationUnit );
 	//Tuples::mutate( translationUnit );