Changeset aee7e35

Timestamp:

Sep 29, 2016, 10:48:09 AM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

7e10773

Parents:

7b69174 (diff), 4b1fd2c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• doc/aaron_comp_II/Efficient Type Resolution in Cforall.pptx (added)
• doc/aaron_comp_II/conversion_dag.png (added)
• doc/aaron_comp_II/resolution_dag.png (added)
• doc/aaron_comp_II/resolution_dag2.odg (added)
• doc/aaron_comp_II/resolution_dag2.png (added)
• src/CodeGen/GenType.cc (modified) (2 diffs)
• src/Common/DebugMalloc.cc (added)
• src/Common/SemanticError.h (modified) (2 diffs)
• src/Common/module.mk (modified) (1 diff)
• src/Common/utility.h (modified) (5 diffs)
• src/Makefile.am (modified) (2 diffs)
• src/Makefile.in (modified) (13 diffs)
• src/Parser/DeclarationNode.cc (modified) (62 diffs)
• src/Parser/ExpressionNode.cc (modified) (2 diffs)
• src/Parser/ParseNode.h (modified) (15 diffs)
• src/Parser/TypeData.cc (modified) (33 diffs)
• src/Parser/TypeData.h (modified) (6 diffs)
• src/Parser/parser.cc (modified) (572 diffs)
• src/Parser/parser.h (modified) (1 diff)
• src/Parser/parser.yy (modified) (15 diffs)
• src/ResolvExpr/AdjustExprType.cc (modified) (2 diffs)
• src/ResolvExpr/CommonType.cc (modified) (5 diffs)
• src/ResolvExpr/ConversionCost.cc (modified) (3 diffs)
• src/ResolvExpr/ConversionCost.h (modified) (1 diff)
• src/ResolvExpr/PtrsAssignable.cc (modified) (2 diffs)
• src/ResolvExpr/PtrsCastable.cc (modified) (2 diffs)
• src/ResolvExpr/RenameVars.cc (modified) (1 diff)
• src/ResolvExpr/RenameVars.h (modified) (1 diff)
• src/ResolvExpr/Resolver.cc (modified) (2 diffs)
• src/ResolvExpr/Unify.cc (modified) (2 diffs)
• src/SymTab/FixFunction.cc (modified) (1 diff)
• src/SymTab/FixFunction.h (modified) (1 diff)
• src/SymTab/ImplementationType.cc (modified) (2 diffs)
• src/SymTab/Mangler.cc (modified) (1 diff)
• src/SymTab/Mangler.h (modified) (1 diff)
• src/SymTab/TypeEquality.cc (modified) (2 diffs)
• src/SynTree/Mutator.cc (modified) (1 diff)
• src/SynTree/Mutator.h (modified) (1 diff)
• src/SynTree/SynTree.h (modified) (1 diff)
• src/SynTree/Type.h (modified) (1 diff)
• src/SynTree/TypeSubstitution.cc (modified) (2 diffs)
• src/SynTree/TypeSubstitution.h (modified) (1 diff)
• src/SynTree/Visitor.cc (modified) (1 diff)
• src/SynTree/Visitor.h (modified) (1 diff)
• src/SynTree/ZeroOneType.cc (added)
• src/SynTree/module.mk (modified) (1 diff)
• src/libcfa/memcheck.awk (added)

src/CodeGen/GenType.cc

@@ -42 +42 @@
                 virtual void visit( TypeInstType *typeInst );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
 
           private:
@@ -200 +202 @@
         }
 
+        void GenType::visit( ZeroType *zeroType ) {
+                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
+                typeString = "int " + typeString;
+                handleQualifiers( zeroType );
+        }
+
+        void GenType::visit( OneType *oneType ) {
+                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
+                typeString = "int " + typeString;
+                handleQualifiers( oneType );
+        }
+
         void GenType::handleQualifiers( Type *type ) {
                 if ( type->get_isConst() ) {

src/Common/SemanticError.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jun  8 14:38:53 2015
-// Update Count     : 4
+// Last Modified On : Sat Sep 24 15:13:42 2016
+// Update Count     : 5
 //
 
@@ -46 +46 @@
 }
 
-
 #endif // SEMANTICERROR_H
 

src/Common/module.mk

@@ -11 +11 @@
 ## Created On       : Mon Jun  1 17:49:17 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Thu Aug 18 13:29:04 2016
-## Update Count     : 2
+## Last Modified On : Tue Sep 27 11:06:38 2016
+## Update Count     : 4
 ###############################################################################
 
 SRC += Common/SemanticError.cc \
        Common/UniqueName.cc \
+       Common/DebugMalloc.cc \
        Common/Assert.cc

src/Common/utility.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun  8 17:33:59 2016
-// Update Count     : 22
+// Last Modified On : Fri Sep 23 11:46:47 2016
+// Update Count     : 28
 //
 
@@ -25 +25 @@
 #include <sstream>
 #include <string>
+#include <cassert>
 
 template< typename T >
@@ -101 +102 @@
                 } // if
         } // for
-}
-
-static inline std::string assign_strptr( const std::string *str ) {
-        if ( str == 0 ) {
-                return "";
-        } else {
-                std::string tmp;
-                tmp = *str;
-                delete str;
-                return tmp;
-        } // if
 }
 
@@ -141 +131 @@
 
 template < typename T >
-void toString_single ( std::ostream & os, const T & value ) {
+void toString_single( std::ostream & os, const T & value ) {
         os << value;
 }
 
 template < typename T, typename... Params >
-void toString_single ( std::ostream & os, const T & value, const Params & ... params ) {
+void toString_single( std::ostream & os, const T & value, const Params & ... params ) {
         os << value;
         toString_single( os, params ... );
@@ -152 +142 @@
 
 template < typename ... Params >
-std::string toString ( const Params & ... params ) {
+std::string toString( const Params & ... params ) {
         std::ostringstream os;
         toString_single( os, params... );

src/Makefile.am

@@ -11 +11 @@
 ## Created On       : Sun May 31 08:51:46 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Sat Aug 20 11:13:12 2016
-## Update Count     : 71
+## Last Modified On : Sat Sep 24 15:03:52 2016
+## Update Count     : 73
 ###############################################################################
 
@@ -40 +40 @@
 cfa_cpplib_PROGRAMS = driver/cfa-cpp
 driver_cfa_cpp_SOURCES = ${SRC}
-driver_cfa_cpp_LDADD = ${LEXLIB}                        # yywrap
+driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -rdynamic -I${abs_top_srcdir}/src/include
 

src/Makefile.in

@@ -98 +98 @@
         Common/driver_cfa_cpp-SemanticError.$(OBJEXT) \
         Common/driver_cfa_cpp-UniqueName.$(OBJEXT) \
+        Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT) \
         Common/driver_cfa_cpp-Assert.$(OBJEXT) \
         ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT) \
@@ -165 +166 @@
         SynTree/driver_cfa_cpp-AttrType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT) \
+        SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Constant.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Expression.$(OBJEXT) \
@@ -358 +360 @@
         CodeGen/CodeGenerator.cc CodeGen/GenType.cc \
         CodeGen/FixNames.cc CodeGen/OperatorTable.cc \
-        Common/SemanticError.cc Common/UniqueName.cc Common/Assert.cc \
+        Common/SemanticError.cc Common/UniqueName.cc \
+        Common/DebugMalloc.cc Common/Assert.cc \
         ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \
         ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \
@@ -390 +393 @@
         SynTree/ReferenceToType.cc SynTree/TupleType.cc \
         SynTree/TypeofType.cc SynTree/AttrType.cc \
-        SynTree/VarArgsType.cc SynTree/Constant.cc \
-        SynTree/Expression.cc SynTree/TupleExpr.cc \
+        SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
+        SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
         SynTree/CommaExpr.cc SynTree/TypeExpr.cc \
         SynTree/ApplicationExpr.cc SynTree/AddressExpr.cc \
@@ -413 +416 @@
 cfa_cpplibdir = ${libdir}
 driver_cfa_cpp_SOURCES = ${SRC}
-driver_cfa_cpp_LDADD = ${LEXLIB}                        # yywrap
+driver_cfa_cpp_LDADD = ${LEXLIB} -ldl                   # yywrap
 driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -rdynamic -I${abs_top_srcdir}/src/include
 all: $(BUILT_SOURCES)
@@ -513 +516 @@
         Common/$(DEPDIR)/$(am__dirstamp)
 Common/driver_cfa_cpp-UniqueName.$(OBJEXT): Common/$(am__dirstamp) \
+        Common/$(DEPDIR)/$(am__dirstamp)
+Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT): Common/$(am__dirstamp) \
         Common/$(DEPDIR)/$(am__dirstamp)
 Common/driver_cfa_cpp-Assert.$(OBJEXT): Common/$(am__dirstamp) \
@@ -715 +720 @@
 SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT): SynTree/$(am__dirstamp) \
+        SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/driver_cfa_cpp-Constant.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
@@ -786 +793 @@
         -rm -f CodeGen/driver_cfa_cpp-OperatorTable.$(OBJEXT)
         -rm -f Common/driver_cfa_cpp-Assert.$(OBJEXT)
+        -rm -f Common/driver_cfa_cpp-DebugMalloc.$(OBJEXT)
         -rm -f Common/driver_cfa_cpp-SemanticError.$(OBJEXT)
         -rm -f Common/driver_cfa_cpp-UniqueName.$(OBJEXT)
@@ -877 +885 @@
         -rm -f SynTree/driver_cfa_cpp-Visitor.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-VoidType.$(OBJEXT)
+        -rm -f SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT)
         -rm -f Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT)
         -rm -f Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT)
@@ -891 +900 @@
 @AMDEP_TRUE@@am__include@ @am__quote@CodeGen/$(DEPDIR)/driver_cfa_cpp-OperatorTable.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-Assert.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-SemanticError.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@
@@ -982 +992 @@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Visitor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VoidType.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Po@am__quote@
@@ -1127 +1138 @@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-UniqueName.obj `if test -f 'Common/UniqueName.cc'; then $(CYGPATH_W) 'Common/UniqueName.cc'; else $(CYGPATH_W) '$(srcdir)/Common/UniqueName.cc'; fi`
 
+Common/driver_cfa_cpp-DebugMalloc.o: Common/DebugMalloc.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-DebugMalloc.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo -c -o Common/driver_cfa_cpp-DebugMalloc.o `test -f 'Common/DebugMalloc.cc' || echo '$(srcdir)/'`Common/DebugMalloc.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Common/DebugMalloc.cc' object='Common/driver_cfa_cpp-DebugMalloc.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-DebugMalloc.o `test -f 'Common/DebugMalloc.cc' || echo '$(srcdir)/'`Common/DebugMalloc.cc
+
+Common/driver_cfa_cpp-DebugMalloc.obj: Common/DebugMalloc.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-DebugMalloc.obj -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo -c -o Common/driver_cfa_cpp-DebugMalloc.obj `if test -f 'Common/DebugMalloc.cc'; then $(CYGPATH_W) 'Common/DebugMalloc.cc'; else $(CYGPATH_W) '$(srcdir)/Common/DebugMalloc.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Tpo Common/$(DEPDIR)/driver_cfa_cpp-DebugMalloc.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Common/DebugMalloc.cc' object='Common/driver_cfa_cpp-DebugMalloc.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Common/driver_cfa_cpp-DebugMalloc.obj `if test -f 'Common/DebugMalloc.cc'; then $(CYGPATH_W) 'Common/DebugMalloc.cc'; else $(CYGPATH_W) '$(srcdir)/Common/DebugMalloc.cc'; fi`
+
 Common/driver_cfa_cpp-Assert.o: Common/Assert.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Common/driver_cfa_cpp-Assert.o -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-Assert.Tpo -c -o Common/driver_cfa_cpp-Assert.o `test -f 'Common/Assert.cc' || echo '$(srcdir)/'`Common/Assert.cc
@@ -2064 +2089 @@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarArgsType.obj `if test -f 'SynTree/VarArgsType.cc'; then $(CYGPATH_W) 'SynTree/VarArgsType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarArgsType.cc'; fi`
+
+SynTree/driver_cfa_cpp-ZeroOneType.o: SynTree/ZeroOneType.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ZeroOneType.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo -c -o SynTree/driver_cfa_cpp-ZeroOneType.o `test -f 'SynTree/ZeroOneType.cc' || echo '$(srcdir)/'`SynTree/ZeroOneType.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ZeroOneType.cc' object='SynTree/driver_cfa_cpp-ZeroOneType.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ZeroOneType.o `test -f 'SynTree/ZeroOneType.cc' || echo '$(srcdir)/'`SynTree/ZeroOneType.cc
+
+SynTree/driver_cfa_cpp-ZeroOneType.obj: SynTree/ZeroOneType.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ZeroOneType.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo -c -o SynTree/driver_cfa_cpp-ZeroOneType.obj `if test -f 'SynTree/ZeroOneType.cc'; then $(CYGPATH_W) 'SynTree/ZeroOneType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ZeroOneType.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ZeroOneType.cc' object='SynTree/driver_cfa_cpp-ZeroOneType.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ZeroOneType.obj `if test -f 'SynTree/ZeroOneType.cc'; then $(CYGPATH_W) 'SynTree/ZeroOneType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ZeroOneType.cc'; fi`
 
 SynTree/driver_cfa_cpp-Constant.o: SynTree/Constant.cc

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Sep 14 23:13:28 2016
-// Update Count     : 502
+// Last Modified On : Mon Sep 26 22:18:40 2016
+// Update Count     : 640
 //
 
@@ -31 +31 @@
 
 // These must remain in the same order as the corresponding DeclarationNode enumerations.
-const char *DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };
-const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };
-const char *DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };
-const char *DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };
-const char *DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };
-const char *DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };
-const char *DeclarationNode::aggregateName[] = { "struct", "union", "context" };
-const char *DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };
-const char *DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
+const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };
+const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };
+const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };
+const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };
+const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };
+const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };
+const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" };
+const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };
+const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
 
 UniqueName DeclarationNode::anonymous( "__anonymous" );
@@ -46 +46 @@
 
 DeclarationNode::DeclarationNode() :
-                type( 0 ),
+                type( nullptr ),
                 storageClass( NoStorageClass ),
                 isInline( false ),
                 isNoreturn( false ),
-                bitfieldWidth( 0 ),
-                initializer( 0 ),
+                bitfieldWidth( nullptr ),
+                initializer( nullptr ),
                 hasEllipsis( false ),
                 linkage( ::linkage ),
                 extension( false ) {
+
+        variable.name = nullptr;
         variable.tyClass = DeclarationNode::Otype;
         variable.assertions = nullptr;
 
+        attr.name = nullptr;
         attr.expr = nullptr;
         attr.type = nullptr;
@@ -63 +66 @@
 
 DeclarationNode::~DeclarationNode() {
+        delete attr.name;
         delete attr.expr;
         delete attr.type;
+
+        delete variable.name;
+        delete variable.assertions;
+
         delete type;
         delete bitfieldWidth;
@@ -70 +78 @@
 }
 
-DeclarationNode *DeclarationNode::clone() const {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::clone() const {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = maybeClone( type );
-        newnode->name = name;
+        newnode->name = name ? new string( *name ) : nullptr;
         newnode->storageClass = storageClass;
         newnode->isInline = isInline;
@@ -83 +91 @@
         newnode->linkage = linkage;
 
+        newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr;
+        newnode->variable.tyClass = variable.tyClass;
         newnode->variable.assertions = maybeClone( variable.assertions );
-        newnode->variable.name = variable.name;
-        newnode->variable.tyClass = variable.tyClass;
-
+
+        newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr;
         newnode->attr.expr = maybeClone( attr.expr );
         newnode->attr.type = maybeClone( attr.type );
@@ -98 +107 @@
 void DeclarationNode::print( std::ostream &os, int indent ) const {
         os << string( indent, ' ' );
-        if ( name == "" ) {
+        if ( name ) {
+                os << *name << ": ";
+        } else {
                 os << "unnamed: ";
-        } else {
-                os << name << ": ";
         } // if
 
@@ -122 +131 @@
         } // if
 
-        if ( initializer != 0 ) {
+        if ( initializer ) {
                 os << endl << string( indent + 2, ' ' ) << "with initializer ";
                 initializer->printOneLine( os );
@@ -139 +148 @@
 }
 
-DeclarationNode *DeclarationNode::newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->name = assign_strptr( name );
-
+DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->name = name;
         newnode->type = new TypeData( TypeData::Function );
         newnode->type->function.params = param;
         newnode->type->function.newStyle = newStyle;
         newnode->type->function.body = body;
-        typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
+        // ignore unnamed routine declarations: void p( int (*)(int) );
+        if ( newnode->name ) {
+                typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID );
+        } // if
 
         if ( body ) {
@@ -155 +166 @@
         if ( ret ) {
                 newnode->type->base = ret->type;
-                ret->type = 0;
+                ret->type = nullptr;
                 delete ret;
         } // if
@@ -163 +174 @@
 
 DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) {
-        DeclarationNode *newnode = new DeclarationNode;
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData();
         newnode->type->qualifiers[ q ] = 1;
@@ -169 +180 @@
 } // DeclarationNode::newQualifier
 
-DeclarationNode * DeclarationNode::newForall( DeclarationNode *forall ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Unknown );
         newnode->type->forall = forall;
@@ -177 +188 @@
 
 DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        //switch (sc) {
-        //      case Inline: newnode->isInline = true; break;
-        //      case Noreturn: newnode->isNoreturn = true; break;
-        //      default: newnode->storageClass = sc; break;
-        //}
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->storageClass = sc;
         return newnode;
@@ -188 +194 @@
 
 DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
-        DeclarationNode *newnode = new DeclarationNode;
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
         newnode->type->basictype = bt;
@@ -195 +201 @@
 
 DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
-        DeclarationNode *newnode = new DeclarationNode;
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
         newnode->type->complextype = ct;
@@ -202 +208 @@
 
 DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
-        DeclarationNode *newnode = new DeclarationNode;
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
         newnode->type->signedness = sn;
@@ -209 +215 @@
 
 DeclarationNode * DeclarationNode::newLength( Length lnth ) {
-        DeclarationNode *newnode = new DeclarationNode;
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
         newnode->type->length = lnth;
@@ -215 +221 @@
 } // DeclarationNode::newLength
 
-DeclarationNode * DeclarationNode::newFromTypedef( std::string *name ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newFromTypedef( string * name ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::SymbolicInst );
-        newnode->type->symbolic.name = assign_strptr( name );
+        newnode->type->symbolic.name = name;
         newnode->type->symbolic.isTypedef = true;
-        newnode->type->symbolic.params = 0;
+        newnode->type->symbolic.params = nullptr;
         return newnode;
 } // DeclarationNode::newFromTypedef
 
-DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
+        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 == "" ) {            // anonymous aggregate ?
-                newnode->type->aggregate.name = anonymous.newName();
+        if ( name ) {
+                newnode->type->aggregate.name = name;
+        } else {                                                                                        // anonymous aggregate ?
+                newnode->type->aggregate.name = new string( anonymous.newName() );
         } // if
         newnode->type->aggregate.actuals = actuals;
@@ -238 +245 @@
 } // DeclarationNode::newAggregate
 
-DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->name = assign_strptr( name );
+DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
-        newnode->type->enumeration.name = newnode->name;
-        if ( newnode->type->enumeration.name == "" ) {          // anonymous enumeration ?
-                newnode->type->enumeration.name = DeclarationNode::anonymous.newName();
+        if ( name ) {
+                newnode->type->enumeration.name = name;
+        } else {                                                                                        // anonymous aggregate ?
+                newnode->type->enumeration.name = new string( anonymous.newName() );
         } // if
         newnode->type->enumeration.constants = constants;
@@ -250 +257 @@
 } // DeclarationNode::newEnum
 
-DeclarationNode *DeclarationNode::newEnumConstant( std::string *name, ExpressionNode *constant ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->name = assign_strptr( name );
+DeclarationNode * DeclarationNode::newEnumConstant( string * name, ExpressionNode * constant ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->name = name;
         newnode->enumeratorValue.reset( constant );
-        typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
+        typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID );
         return newnode;
 } // DeclarationNode::newEnumConstant
 
-DeclarationNode *DeclarationNode::newName( std::string *name ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->name = assign_strptr( name );
+DeclarationNode * DeclarationNode::newName( string * name ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->name = name;
         return newnode;
 } // DeclarationNode::newName
 
-DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newFromTypeGen( string * name, ExpressionNode * params ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::SymbolicInst );
-        newnode->type->symbolic.name = assign_strptr( name );
+        newnode->type->symbolic.name = name;
         newnode->type->symbolic.isTypedef = false;
         newnode->type->symbolic.actuals = params;
@@ -273 +280 @@
 } // DeclarationNode::newFromTypeGen
 
-DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->name = assign_strptr( name );
-        newnode->type = new TypeData( TypeData::Variable );
+DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, string * name ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = nullptr;
         newnode->variable.tyClass = tc;
-        newnode->variable.name = newnode->name;
+        newnode->variable.name = name;
         return newnode;
 } // DeclarationNode::newTypeParam
 
-DeclarationNode *DeclarationNode::newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newTrait( const string * name, DeclarationNode * params, DeclarationNode * asserts ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
+        newnode->type->aggregate.name = name;
         newnode->type->aggregate.kind = Trait;
         newnode->type->aggregate.params = params;
         newnode->type->aggregate.fields = asserts;
-        newnode->type->aggregate.name = assign_strptr( name );
         return newnode;
 } // DeclarationNode::newTrait
 
-DeclarationNode *DeclarationNode::newTraitUse( std::string *name, ExpressionNode *params ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newTraitUse( const 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 = Trait;
-        newnode->type->aggInst.aggregate->aggregate.name = assign_strptr( name );
+        newnode->type->aggInst.aggregate->aggregate.name = name;
         newnode->type->aggInst.params = params;
         return newnode;
 } // DeclarationNode::newTraitUse
 
-DeclarationNode *DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->name = assign_strptr( name );
+DeclarationNode * DeclarationNode::newTypeDecl( string * name, DeclarationNode * typeParams ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Symbolic );
         newnode->type->symbolic.isTypedef = false;
         newnode->type->symbolic.params = typeParams;
-        newnode->type->symbolic.name = newnode->name;
+        newnode->type->symbolic.name = name;
         return newnode;
 } // DeclarationNode::newTypeDecl
 
-DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Pointer );
         return newnode->addQualifiers( qualifiers );
 } // DeclarationNode::newPointer
 
-DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) {
-        DeclarationNode *newnode = new DeclarationNode;
+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;
-        if ( newnode->type->array.dimension == 0 || newnode->type->array.dimension->isExpressionType<ConstantExpr *>() ) {
+        if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType<ConstantExpr * >() ) {
                 newnode->type->array.isVarLen = false;
         } else {
@@ -331 +336 @@
 } // DeclarationNode::newArray
 
-DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newVarArray( DeclarationNode * qualifiers ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Array );
-        newnode->type->array.dimension = 0;
+        newnode->type->array.dimension = nullptr;
         newnode->type->array.isStatic = false;
         newnode->type->array.isVarLen = true;
@@ -340 +345 @@
 }
 
-DeclarationNode *DeclarationNode::newBitfield( ExpressionNode *size ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newBitfield( ExpressionNode * size ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->bitfieldWidth = size;
         return newnode;
 }
 
-DeclarationNode *DeclarationNode::newTuple( DeclarationNode *members ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newTuple( DeclarationNode * members ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Tuple );
         newnode->type->tuple = members;
@@ -353 +358 @@
 }
 
-DeclarationNode *DeclarationNode::newTypeof( ExpressionNode *expr ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Typeof );
         newnode->type->typeexpr = expr;
@@ -361 +366 @@
 
 DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) {
-        DeclarationNode *newnode = new DeclarationNode;
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Builtin );
         newnode->builtin = bt;
@@ -367 +372 @@
 } // DeclarationNode::newBuiltinType
 
-DeclarationNode *DeclarationNode::newAttr( std::string *name, ExpressionNode *expr ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Attr );
-        newnode->attr.name = assign_strptr( name );
+DeclarationNode * DeclarationNode::newAttr( string * name, ExpressionNode * expr ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = nullptr;
+        newnode->attr.name = name;
         newnode->attr.expr = expr;
         return newnode;
 }
 
-DeclarationNode *DeclarationNode::newAttr( std::string *name, DeclarationNode *type ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Attr );
-        newnode->attr.name = assign_strptr( name );
+DeclarationNode * DeclarationNode::newAttr( string * name, DeclarationNode * type ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = nullptr;
+        newnode->attr.name = name;
         newnode->attr.type = type;
         return newnode;
@@ -389 +394 @@
 } // appendError
 
-void DeclarationNode::checkQualifiers( const TypeData *src, const TypeData *dst ) {
+void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
         TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
 
@@ -401 +406 @@
 } // DeclarationNode::checkQualifiers
 
-void DeclarationNode::checkStorageClasses( DeclarationNode *q ) {
+void DeclarationNode::checkStorageClasses( DeclarationNode * q ) {
         if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) {
                 if ( storageClass == q->storageClass ) {                // duplicate qualifier
@@ -413 +418 @@
 } // DeclarationNode::copyStorageClasses
 
-DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
+DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) {
         isInline = isInline || q->isInline;
         isNoreturn = isNoreturn || q->isNoreturn;
@@ -424 +429 @@
 } // DeclarationNode::copyStorageClasses
 
-static void addQualifiersToType( TypeData *&src, TypeData *dst ) {
+static void addQualifiersToType( TypeData *&src, TypeData * dst ) {
         if ( src->forall && dst->kind == TypeData::Function ) {
                 if ( dst->forall ) {
@@ -431 +436 @@
                         dst->forall = src->forall;
                 } // if
-                src->forall = 0;
+                src->forall = nullptr;
         } // if
         if ( dst->base ) {
@@ -437 +442 @@
         } else if ( dst->kind == TypeData::Function ) {
                 dst->base = src;
-                src = 0;
+                src = nullptr;
         } else {
                 dst->qualifiers |= src->qualifiers;
@@ -443 +448 @@
 } // addQualifiersToType
 
-DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
-        if ( ! q ) return this;
+DeclarationNode * DeclarationNode::addQualifiers( DeclarationNode * q ) {
+        if ( ! q ) { delete q; return this; }
 
         checkStorageClasses( q );
         copyStorageClasses( q );
 
-        if ( ! q->type ) { delete q; return this; }
+        if ( ! q->type ) {
+                delete q;
+                return this;
+        } // if
 
         if ( ! type ) {
-//              type = new TypeData;
-                type = q->type;
+                type = q->type;                                                                 // reuse this structure
+                q->type = nullptr;
+                delete q;
                 return this;
         } // if
@@ -467 +476 @@
                                 type->aggregate.params = q->type->forall;
                                 // change implicit typedef from TYPEDEFname to TYPEGENname
-                                typedefTable.changeKind( type->aggregate.name, TypedefTable::TG );
+                                typedefTable.changeKind( *type->aggregate.name, TypedefTable::TG );
                         } else {
                                 type->forall = q->type->forall;
                         } // if
                 } // if
-                q->type->forall = 0;
+                q->type->forall = nullptr;
         } // if
         delete q;
@@ -485 +494 @@
                         dst->forall = src->forall;
                 } // if
-                src->forall = 0;
+                src->forall = nullptr;
         } // if
         if ( dst->base ) {
@@ -494 +503 @@
                         src->qualifiers |= dst->qualifiers;
                         dst = src;
-                        src = 0;
+                        src = nullptr;
                         break;
                   case TypeData::Basic:
@@ -504 +513 @@
                                         dst->basictype = src->basictype;
                                 } else if ( src->basictype != DeclarationNode::NoBasicType )
-                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
 
                                 if ( dst->complextype == DeclarationNode::NoComplexType ) {
                                         dst->complextype = src->complextype;
                                 } else if ( src->complextype != DeclarationNode::NoComplexType )
-                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
 
                                 if ( dst->signedness == DeclarationNode::NoSignedness ) {
                                         dst->signedness = src->signedness;
                                 } else if ( src->signedness != DeclarationNode::NoSignedness )
-                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
 
                                 if ( dst->length == DeclarationNode::NoLength ) {
@@ -521 +530 @@
                                         dst->length = DeclarationNode::LongLong;
                                 } else if ( src->length != DeclarationNode::NoLength )
-                                        throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
                         } // if
                         break;
@@ -534 +543 @@
                                 } // if
                                 dst->base->qualifiers |= src->qualifiers;
-                                src = 0;
+                                src = nullptr;
                                 break;
                           default:
@@ -542 +551 @@
                                         dst->forall = src->forall;
                                 } // if
-                                src->forall = 0;
+                                src->forall = nullptr;
                                 dst->base = src;
-                                src = 0;
+                                src = nullptr;
                         } // switch
                 } // switch
@@ -550 +559 @@
 }
 
-DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
+DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) {
         if ( o ) {
                 checkStorageClasses( o );
@@ -566 +575 @@
                                         type = o->type;
                                 } // if
-                                o->type = 0;
+                                o->type = nullptr;
                         } else {
                                 addTypeToType( o->type, type );
@@ -584 +593 @@
 }
 
-DeclarationNode *DeclarationNode::addTypedef() {
-        TypeData *newtype = new TypeData( TypeData::Symbolic );
-        newtype->symbolic.params = 0;
+DeclarationNode * DeclarationNode::addTypedef() {
+        TypeData * newtype = new TypeData( TypeData::Symbolic );
+        newtype->symbolic.params = nullptr;
         newtype->symbolic.isTypedef = true;
-        newtype->symbolic.name = name;
+        newtype->symbolic.name = name ? new string( *name ) : nullptr;
         newtype->base = type;
         type = newtype;
@@ -594 +603 @@
 }
 
-DeclarationNode *DeclarationNode::addAssertions( DeclarationNode *assertions ) {
+DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) {
+        if ( variable.name ) {
+                if ( variable.assertions ) {
+                        variable.assertions->appendList( assertions );
+                } else {
+                        variable.assertions = assertions;
+                } // if
+                return this;
+        } // if
+
         assert( type );
         switch ( type->kind ) {
@@ -604 +622 @@
                 } // if
                 break;
-          case TypeData::Variable:
-                if ( variable.assertions ) {
-                        variable.assertions->appendList( assertions );
-                } else {
-                        variable.assertions = assertions;
-                } // if
-                break;
+          // case TypeData::Variable:
+          //    if ( variable.assertions ) {
+          //            variable.assertions->appendList( assertions );
+          //    } else {
+          //            variable.assertions = assertions;
+          //    } // if
+          //    break;
           default:
                 assert( false );
@@ -618 +636 @@
 }
 
-DeclarationNode *DeclarationNode::addName( std::string *newname ) {
-        name = assign_strptr( newname );
-        return this;
-}
-
-DeclarationNode *DeclarationNode::addBitfield( ExpressionNode *size ) {
+DeclarationNode * DeclarationNode::addName( string * newname ) {
+        assert( ! name );
+        name = newname;
+        return this;
+}
+
+DeclarationNode * DeclarationNode::addBitfield( ExpressionNode * size ) {
         bitfieldWidth = size;
         return this;
 }
 
-DeclarationNode *DeclarationNode::addVarArgs() {
+DeclarationNode * DeclarationNode::addVarArgs() {
         assert( type );
         hasEllipsis = true;
@@ -634 +653 @@
 }
 
-DeclarationNode *DeclarationNode::addFunctionBody( StatementNode *body ) {
+DeclarationNode * DeclarationNode::addFunctionBody( StatementNode * body ) {
         assert( type );
         assert( type->kind == TypeData::Function );
-        assert( type->function.body == 0 );
+        assert( ! type->function.body );
         type->function.body = body;
         type->function.hasBody = true;
@@ -643 +662 @@
 }
 
-DeclarationNode *DeclarationNode::addOldDeclList( DeclarationNode *list ) {
+DeclarationNode * DeclarationNode::addOldDeclList( DeclarationNode * list ) {
         assert( type );
         assert( type->kind == TypeData::Function );
-        assert( type->function.oldDeclList == 0 );
+        assert( ! type->function.oldDeclList );
         type->function.oldDeclList = list;
         return this;
 }
 
-static void setBase( TypeData *&type, TypeData *newType ) {
+static void setBase( TypeData *&type, TypeData * newType ) {
         if ( type ) {
-                TypeData *prevBase = type;
-                TypeData *curBase = type->base;
-                while ( curBase != 0 ) {
+                TypeData * prevBase = type;
+                TypeData * curBase = type->base;
+                while ( curBase != nullptr ) {
                         prevBase = curBase;
                         curBase = curBase->base;
@@ -665 +684 @@
 }
 
-DeclarationNode *DeclarationNode::addPointer( DeclarationNode *p ) {
+DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) {
         if ( p ) {
                 assert( p->type->kind == TypeData::Pointer );
                 setBase( type, p->type );
-                p->type = 0;
+                p->type = nullptr;
                 delete p;
         } // if
@@ -675 +694 @@
 }
 
-DeclarationNode *DeclarationNode::addArray( DeclarationNode *a ) {
+DeclarationNode * DeclarationNode::addArray( DeclarationNode * a ) {
         if ( a ) {
                 assert( a->type->kind == TypeData::Array );
                 setBase( type, a->type );
-                a->type = 0;
+                a->type = nullptr;
                 delete a;
         } // if
@@ -685 +704 @@
 }
 
-DeclarationNode *DeclarationNode::addNewPointer( DeclarationNode *p ) {
+DeclarationNode * DeclarationNode::addNewPointer( DeclarationNode * p ) {
         if ( p ) {
                 assert( p->type->kind == TypeData::Pointer );
@@ -703 +722 @@
                                 p->type->base = type;
                         } // switch
-                        type = 0;
+                        type = nullptr;
                 } // if
                 delete this;
@@ -712 +731 @@
 }
 
-static TypeData *findLast( TypeData *a ) {
+static TypeData * findLast( TypeData * a ) {
         assert( a );
-        TypeData *cur = a;
+        TypeData * cur = a;
         while ( cur->base ) {
                 cur = cur->base;
@@ -721 +740 @@
 }
 
-DeclarationNode *DeclarationNode::addNewArray( DeclarationNode *a ) {
+DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) {
         if ( a ) {
                 assert( a->type->kind == TypeData::Array );
-                TypeData *lastArray = findLast( a->type );
+                TypeData * lastArray = findLast( a->type );
                 if ( type ) {
                         switch ( type->kind ) {
@@ -739 +758 @@
                                 lastArray->base = type;
                         } // switch
-                        type = 0;
+                        type = nullptr;
                 } // if
                 delete this;
@@ -748 +767 @@
 }
 
-DeclarationNode *DeclarationNode::addParamList( DeclarationNode *params ) {
-        TypeData *ftype = new TypeData( TypeData::Function );
+DeclarationNode * DeclarationNode::addParamList( DeclarationNode * params ) {
+        TypeData * ftype = new TypeData( TypeData::Function );
         ftype->function.params = params;
         setBase( type, ftype );
@@ -755 +774 @@
 }
 
-static TypeData *addIdListToType( TypeData *type, DeclarationNode *ids ) {
+static TypeData * addIdListToType( TypeData * type, DeclarationNode * ids ) {
         if ( type ) {
                 if ( type->kind != TypeData::Function ) {
@@ -764 +783 @@
                 return type;
         } else {
-                TypeData *newtype = new TypeData( TypeData::Function );
+                TypeData * newtype = new TypeData( TypeData::Function );
                 newtype->function.idList = ids;
                 return newtype;
         } // if
-}
-
-DeclarationNode *DeclarationNode::addIdList( DeclarationNode *ids ) {
+} // addIdListToType
+
+DeclarationNode * DeclarationNode::addIdList( DeclarationNode * ids ) {
         type = addIdListToType( type, ids );
         return this;
 }
 
-DeclarationNode *DeclarationNode::addInitializer( InitializerNode *init ) {
-        //assert
+DeclarationNode * DeclarationNode::addInitializer( InitializerNode * init ) {
         initializer = init;
         return this;
 }
 
-DeclarationNode *DeclarationNode::cloneBaseType( string *newName ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        TypeData *srcType = type;
-        while ( srcType->base ) {
-                srcType = srcType->base;
-        } // while
-        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.fields;
-                        newnode->type->aggInst.aggregate->aggregate.fields = 0;
-                } // if
-        } // if
-        newnode->type->forall = maybeClone( type->forall );
-        assert( storageClass == NoStorageClass );
-        newnode->copyStorageClasses( this );
-        newnode->name = assign_strptr( newName );
-        return newnode;
-}
-
-DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) {
-        if ( o ) {
-                o->copyStorageClasses( this );
-                if ( type ) {
-                        TypeData *srcType = type;
-                        while ( srcType->base ) {
-                                srcType = srcType->base;
-                        } // while
-                        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.fields;
-                                        newType->aggInst.aggregate->aggregate.fields = 0;
-                                } // if
-                        } // if
-                        newType->forall = maybeClone( type->forall );
-                        if ( ! o->type ) {
-                                o->type = newType;
-                        } else {
-                                addTypeToType( newType, o->type );
-                                delete newType;
-                        } // if
-                } // if
-        } // if
-        return o;
-}
-
-DeclarationNode *DeclarationNode::cloneType( string *newName ) {
-        DeclarationNode *newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::cloneType( string * newName ) {
+        DeclarationNode * newnode = new DeclarationNode;
         newnode->type = maybeClone( type );
         assert( storageClass == NoStorageClass );
         newnode->copyStorageClasses( this );
-        newnode->name = assign_strptr( newName );
-        return newnode;
-}
-
-DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
-        if ( o ) {
-                assert( storageClass == NoStorageClass );
-                o->copyStorageClasses( this );
-                if ( type ) {
-                        TypeData *newType = type->clone();
-                        if ( ! o->type ) {
-                                o->type = newType;
+        assert( newName );
+        newnode->name = newName;
+        return newnode;
+}
+
+DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o ) {
+        if ( ! o ) return nullptr;
+
+        o->copyStorageClasses( this );
+        if ( type ) {
+                TypeData * srcType = type;
+
+                while ( srcType->base ) {
+                        srcType = srcType->base;
+                } // while
+
+                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 = nullptr;
                         } else {
-                                addTypeToType( newType, o->type );
-                                delete newType;
+                                assert( newType->aggInst.aggregate->kind == TypeData::Aggregate );
+                                delete newType->aggInst.aggregate->aggregate.fields;
+                                newType->aggInst.aggregate->aggregate.fields = nullptr;
                         } // if
                 } // if
-        } // if
-        delete o;
+
+                newType->forall = maybeClone( type->forall );
+                if ( ! o->type ) {
+                        o->type = newType;
+                } else {
+                        addTypeToType( newType, o->type );
+                        delete newType;
+                } // if
+        } // if
         return o;
 }
 
-DeclarationNode *DeclarationNode::extractAggregate() const {
+DeclarationNode * DeclarationNode::extractAggregate() const {
         if ( type ) {
-                TypeData *ret = typeextractAggregate( type );
+                TypeData * ret = typeextractAggregate( type );
                 if ( ret ) {
-                        DeclarationNode *newnode = new DeclarationNode;
+                        DeclarationNode * newnode = new DeclarationNode;
                         newnode->type = ret;
                         return newnode;
                 } // if
         } // if
-        return 0;
-}
-
-void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList ) {
+        return nullptr;
+}
+
+void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList ) {
         SemanticError errors;
         std::back_insert_iterator< std::list< Declaration * > > out( outputList );
-        const DeclarationNode *cur = firstNode;
+        const DeclarationNode * cur = firstNode;
+
         while ( cur ) {
                 try {
-                        if ( DeclarationNode *extr = cur->extractAggregate() ) {
+                        if ( DeclarationNode * extr = cur->extractAggregate() ) {
                                 // handle the case where a structure declaration is contained within an object or type declaration
-                                Declaration *decl = extr->build();
+                                Declaration * decl = extr->build();
                                 if ( decl ) {
-                                        *out++ = decl;
+                                        * out++ = decl;
                                 } // if
                                 delete extr;
                         } // if
-                        Declaration *decl = cur->build();
+
+                        Declaration * decl = cur->build();
                         if ( decl ) {
-                                *out++ = decl;
+                                * out++ = decl;
                         } // if
                 } catch( SemanticError &e ) {
@@ -900 +881 @@
                 cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
         } // while
+
         if ( ! errors.isEmpty() ) {
                 throw errors;
         } // if
-}
-
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList ) {
+} // buildList
+
+void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) {
         SemanticError errors;
         std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList );
-        const DeclarationNode *cur = firstNode;
+        const DeclarationNode * cur = firstNode;
         while ( cur ) {
                 try {
-                        Declaration *decl = cur->build();
+                        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( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
+                                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( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
                                         delete agg;
-                                } else if ( UnionDecl *agg = dynamic_cast< UnionDecl * >( decl ) ) {
-                                        UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
-                                        *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
+                                } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
+                                        UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
+                                        * out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
                                 } // if
                         } // if
@@ -932 +914 @@
                 throw errors;
         } // if
-}
-
-void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList ) {
+} // buildList
+
+void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList ) {
         SemanticError errors;
         std::back_insert_iterator< std::list< Type * > > out( outputList );
-        const DeclarationNode *cur = firstNode;
+        const DeclarationNode * cur = firstNode;
+
         while ( cur ) {
                 try {
-                        *out++ = cur->buildType();
+                        * out++ = cur->buildType();
                 } catch( SemanticError &e ) {
                         errors.append( e );
@@ -946 +929 @@
                 cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
         } // while
+
         if ( ! errors.isEmpty() ) {
                 throw errors;
         } // if
-}
-
-Declaration *DeclarationNode::build() const {
+} // buildTypeList
+
+Declaration * DeclarationNode::build() const {
         if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this );
+
+        if ( variable.name ) {
+                static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
+                TypeDecl * ret = new TypeDecl( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
+                buildList( variable.assertions, ret->get_assertions() );
+                return ret;
+        } // if
+
         if ( type ) {
-                if ( type->kind == TypeData::Variable ) {
-                        static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
-                        TypeDecl * ret = new TypeDecl( variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ variable.tyClass ] );
-                        buildList( variable.assertions, ret->get_assertions() );
-                        return ret;
+                return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
+        } // if
+
+        if ( ! isInline && ! isNoreturn ) {
+                assertf( name, "ObjectDecl are assumed to have names\n" );
+                return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
+        } // if
+
+        throw SemanticError( "invalid function specifier ", this );
+}
+
+Type * DeclarationNode::buildType() const {
+        assert( type );
+
+        if ( attr.name ) {
+                AttrType * ret;
+                if ( attr.expr ) {
+                        ret = new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() );
                 } else {
-                        return buildDecl( type, name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
-                } // if
-        } // if
-        if ( ! isInline && ! isNoreturn ) {
-                return (new ObjectDecl( name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
-        } // if
-        throw SemanticError( "invalid function specifier ", this );
-}
-
-Type *DeclarationNode::buildType() const {
-        assert( type );
+                        assert( attr.type );
+                        ret = new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() );
+                } // if
+                return ret;
+        } // if
 
         switch ( type->kind ) {
           case TypeData::Enum:
-                return new EnumInstType( buildQualifiers( type ), type->enumeration.name );
+                return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
           case TypeData::Aggregate: {
-                  ReferenceToType *ret;
+                  ReferenceToType * ret;
                   switch ( type->aggregate.kind ) {
                         case DeclarationNode::Struct:
-                          ret = new StructInstType( buildQualifiers( type ), type->aggregate.name );
+                          ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;
                         case DeclarationNode::Union:
-                          ret = new UnionInstType( buildQualifiers( type ), type->aggregate.name );
+                          ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;
                         case DeclarationNode::Trait:
-                          ret = new TraitInstType( buildQualifiers( type ), type->aggregate.name );
+                          ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;
                         default:
@@ -994 +993 @@
           }
           case TypeData::Symbolic: {
-                  TypeInstType *ret = new TypeInstType( buildQualifiers( type ), type->symbolic.name, false );
+                  TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false );
                   buildList( type->symbolic.actuals, ret->get_parameters() );
-                  return ret;
-          }
-          case TypeData::Attr: {
-                  assert( type->kind == TypeData::Attr );
-                  // assert( type->attr );
-                  AttrType * ret;
-                  if ( attr.expr ) {
-                          ret = new AttrType( buildQualifiers( type ), attr.name, attr.expr->build() );
-                  } else {
-                          assert( attr.type );
-                          ret = new AttrType( buildQualifiers( type ), attr.name, attr.type->buildType() );
-                  } // if
                   return ret;
           }

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 25 21:39:40 2016
-// Update Count     : 503
+// Last Modified On : Fri Sep 16 16:27:44 2016
+// Update Count     : 508
 //
 
@@ -31 +31 @@
 
 using namespace std;
-
-ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.get_name() ), extension( other.extension ) {}
 
 //##############################################################################

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 12 08:00:05 2016
-// Update Count     : 603
+// Last Modified On : Sat Sep 24 11:12:04 2016
+// Update Count     : 633
 //
 
@@ -41 +41 @@
   public:
         ParseNode() {};
-        ParseNode( const std::string * name ) : name( * name ) { assert( false ); delete name; }
-        ParseNode( const std::string &name ) : name( name ) { assert( false ); }
-        virtual ~ParseNode() { delete next; };
+        virtual ~ParseNode() { delete next; delete name; };
         virtual ParseNode * clone() const = 0;
 
         ParseNode * get_next() const { return next; }
         ParseNode * set_next( ParseNode * newlink ) { next = newlink; return this; }
+
         ParseNode * get_last() {
                 ParseNode * current;
-                for ( current = this; current->get_next() != 0; current = current->get_next() );
+                for ( current = this; current->get_next() != nullptr; current = current->get_next() );
                 return current;
         }
         ParseNode * set_last( ParseNode * newlast ) {
-                if ( newlast != 0 ) get_last()->set_next( newlast );
+                if ( newlast != nullptr ) get_last()->set_next( newlast );
                 return this;
         }
-
-        const std::string &get_name() const { return name; }
-        void set_name( const std::string &newValue ) { name = newValue; }
 
         virtual void print( std::ostream &os, int indent = 0 ) const {}
         virtual void printList( std::ostream &os, int indent = 0 ) const {}
-  private:
+
         static int indent_by;
 
         ParseNode * next = nullptr;
-        std::string name;
+        std::string * name = nullptr;
 }; // ParseNode
 
@@ -74 +70 @@
 class InitializerNode : public ParseNode {
   public:
-        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = 0 );
-        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = 0 );
+        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
+        InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
         ~InitializerNode();
         virtual InitializerNode * clone() const { assert( false ); return nullptr; }
@@ -106 +102 @@
   public:
         ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {}
-        ExpressionNode( Expression * expr, const std::string * name ) : ParseNode( name ), expr( expr ) {}
         ExpressionNode( const ExpressionNode &other );
         virtual ~ExpressionNode() {}
@@ -183 +178 @@
 Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
 Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
-Expression * build_tuple( ExpressionNode * expr_node = 0 );
+Expression * build_tuple( ExpressionNode * expr_node = nullptr );
 Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
 Expression * build_range( ExpressionNode * low, ExpressionNode * high );
@@ -219 +214 @@
         static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
         static DeclarationNode * newQualifier( Qualifier );
-        static DeclarationNode * newForall( DeclarationNode *);
+        static DeclarationNode * newForall( DeclarationNode * );
         static DeclarationNode * newStorageClass( StorageClass );
         static DeclarationNode * newBasicType( BasicType );
@@ -226 +221 @@
         static DeclarationNode * newLength( Length lnth );
         static DeclarationNode * newBuiltinType( BuiltinType );
-        static DeclarationNode * newFromTypedef( std::string *);
+        static DeclarationNode * newFromTypedef( std::string * );
         static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
         static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants );
         static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
-        static DeclarationNode * newName( std::string *);
+        static DeclarationNode * newName( std::string * );
         static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
-        static DeclarationNode * newTypeParam( TypeClass, std::string *);
-        static DeclarationNode * newTrait( std::string * name, DeclarationNode * params, DeclarationNode * asserts );
-        static DeclarationNode * newTraitUse( std::string * name, ExpressionNode * params );
+        static DeclarationNode * newTypeParam( TypeClass, std::string * );
+        static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
+        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
         static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
         static DeclarationNode * newPointer( DeclarationNode * qualifiers );
@@ -249 +244 @@
         DeclarationNode * clone() const;
 
-        DeclarationNode * addQualifiers( DeclarationNode *);
+        DeclarationNode * addQualifiers( DeclarationNode * );
         void checkQualifiers( const TypeData *, const TypeData * );
-        void checkStorageClasses( DeclarationNode *q );
-        DeclarationNode * copyStorageClasses( DeclarationNode *);
-        DeclarationNode * addType( DeclarationNode *);
+        void checkStorageClasses( DeclarationNode * );
+        DeclarationNode * copyStorageClasses( DeclarationNode * );
+        DeclarationNode * addType( DeclarationNode * );
         DeclarationNode * addTypedef();
-        DeclarationNode * addAssertions( DeclarationNode *);
-        DeclarationNode * addName( std::string *);
+        DeclarationNode * addAssertions( DeclarationNode * );
+        DeclarationNode * addName( std::string * );
         DeclarationNode * addBitfield( ExpressionNode * size );
         DeclarationNode * addVarArgs();
@@ -270 +265 @@
 
         DeclarationNode * cloneType( std::string * newName );
-        DeclarationNode * cloneType( DeclarationNode * existing );
-        DeclarationNode * cloneType( int ) { return cloneType( ( std::string *)0 ); }
-        DeclarationNode * cloneBaseType( std::string * newName );
         DeclarationNode * cloneBaseType( DeclarationNode * newdecl );
 
@@ -286 +278 @@
 
         bool get_hasEllipsis() const;
-        const std::string &get_name() const { return name; }
         LinkageSpec::Spec get_linkage() const { return linkage; }
         DeclarationNode * extractAggregate() const;
@@ -295 +286 @@
         DeclarationNode * set_extension( bool exten ) { extension = exten; return this; }
   public:
-        // StorageClass buildStorageClass() const;
-        // bool buildFuncSpecifier( StorageClass key ) const;
-
         struct Variable_t {
+                const std::string * name;
                 DeclarationNode::TypeClass tyClass;
-                std::string name;
                 DeclarationNode * assertions;
         };
@@ -306 +294 @@
 
         struct Attr_t {
-                std::string name;
+                const std::string * name;
                 ExpressionNode * expr;
                 DeclarationNode * type;
@@ -315 +303 @@
 
         TypeData * type;
-        std::string name;
         StorageClass storageClass;
         bool isInline, isNoreturn;
@@ -331 +318 @@
 
 Type * buildType( TypeData * type );
-//Type::Qualifiers buildQualifiers( const TypeData::Qualifiers & qualifiers );
 
 static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
@@ -393 +379 @@
 Statement * build_finally( StatementNode * stmt );
 Statement * build_compound( StatementNode * first );
-Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = 0, ExpressionNode * input = 0, ExpressionNode * clobber = 0, LabelNode * gotolabels = 0 );
+Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
 
 //##############################################################################

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 12 21:11:22 2016
-// Update Count     : 377
+// Last Modified On : Sat Sep 24 11:14:26 2016
+// Update Count     : 415
 //
 
@@ -24 +24 @@
 #include "SynTree/Statement.h"
 #include "SynTree/Initializer.h"
-
-TypeData::TypeData( Kind k ) : kind( k ), base( 0 ), forall( 0 ) {
+using namespace std;
+
+TypeData::TypeData( Kind k ) : kind( k ), base( nullptr ), forall( nullptr ) {
         switch ( kind ) {
           case Unknown:
@@ -37 +38 @@
           case Array:
                 // array = new Array_t;
-                array.dimension = 0;
+                array.dimension = nullptr;
                 array.isVarLen = false;
                 array.isStatic = false;
@@ -43 +44 @@
           case Function:
                 // function = new Function_t;
-                function.params = 0;
-                function.idList = 0;
-                function.oldDeclList = 0;
-                function.body = 0;
+                function.params = nullptr;
+                function.idList = nullptr;
+                function.oldDeclList = nullptr;
+                function.body = nullptr;
                 function.hasBody = false;
                 function.newStyle = false;
@@ -52 +53 @@
           case Aggregate:
                 // aggregate = new Aggregate_t;
-                aggregate.params = 0;
-                aggregate.actuals = 0;
-                aggregate.fields = 0;
+                aggregate.name = nullptr;
+                aggregate.params = nullptr;
+                aggregate.actuals = nullptr;
+                aggregate.fields = nullptr;
                 break;
           case AggregateInst:
                 // aggInst = new AggInst_t;
-                aggInst.aggregate = 0;
-                aggInst.params = 0;
+                aggInst.aggregate = nullptr;
+                aggInst.params = nullptr;
                 break;
           case Enum:
                 // enumeration = new Enumeration_t;
-                enumeration.constants = 0;
+                enumeration.name = nullptr;
+                enumeration.constants = nullptr;
                 break;
           case Symbolic:
           case SymbolicInst:
                 // symbolic = new Symbolic_t;
-                symbolic.params = 0;
-                symbolic.actuals = 0;
-                symbolic.assertions = 0;
-                break;
-          case Variable:
-                // variable = new Variable_t;
-                // variable.tyClass = DeclarationNode::Type;
-                // variable.assertions = 0;
+                symbolic.name = nullptr;
+                symbolic.params = nullptr;
+                symbolic.actuals = nullptr;
+                symbolic.assertions = nullptr;
                 break;
           case Tuple:
@@ -84 +83 @@
                 // typeexpr = new Typeof_t;
                 typeexpr = nullptr;
-                break;
-          case Attr:
-                // attr = new Attr_t;
-                // attr.expr = nullptr;
-                // attr.type = nullptr;
                 break;
           case Builtin:
@@ -121 +115 @@
                 break;
           case Aggregate:
+                delete aggregate.name;
                 delete aggregate.params;
                 delete aggregate.actuals;
@@ -132 +127 @@
                 break;
           case Enum:
+                delete enumeration.name;
                 delete enumeration.constants;
                 // delete enumeration;
@@ -137 +133 @@
           case Symbolic:
           case SymbolicInst:
+                delete symbolic.name;
                 delete symbolic.params;
                 delete symbolic.actuals;
@@ -142 +139 @@
                 // delete symbolic;
                 break;
-          case Variable:
-                // delete variable.assertions;
-                // delete variable;
-                break;
           case Tuple:
                 // delete tuple->members;
@@ -153 +146 @@
                 // delete typeexpr->expr;
                 delete typeexpr;
-                break;
-          case Attr:
-                // delete attr.expr;
-                // delete attr.type;
-                // delete attr;
                 break;
           case Builtin:
@@ -197 +185 @@
                 break;
           case Aggregate:
+                newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
                 newtype->aggregate.params = maybeClone( aggregate.params );
                 newtype->aggregate.actuals = maybeClone( aggregate.actuals );
                 newtype->aggregate.fields = maybeClone( aggregate.fields );
-                newtype->aggregate.name = aggregate.name;
                 newtype->aggregate.kind = aggregate.kind;
                 newtype->aggregate.body = aggregate.body;
@@ -209 +197 @@
                 break;
           case Enum:
-                newtype->enumeration.name = enumeration.name;
+                newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr;
                 newtype->enumeration.constants = maybeClone( enumeration.constants );
                 break;
           case Symbolic:
           case SymbolicInst:
+                newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr;
                 newtype->symbolic.params = maybeClone( symbolic.params );
                 newtype->symbolic.actuals = maybeClone( symbolic.actuals );
                 newtype->symbolic.assertions = maybeClone( symbolic.assertions );
                 newtype->symbolic.isTypedef = symbolic.isTypedef;
-                newtype->symbolic.name = symbolic.name;
-                break;
-          case Variable:
-                assert( false );
-                // newtype->variable.assertions = maybeClone( variable.assertions );
-                // newtype->variable.name = variable.name;
-                // newtype->variable.tyClass = variable.tyClass;
                 break;
           case Tuple:
@@ -231 +213 @@
           case Typeof:
                 newtype->typeexpr = maybeClone( typeexpr );
-                break;
-          case Attr:
-                assert( false );
-                // newtype->attr.expr = maybeClone( attr.expr );
-                // newtype->attr.type = maybeClone( attr.type );
                 break;
           case Builtin:
@@ -245 +222 @@
 } // TypeData::clone
 
-void TypeData::print( std::ostream &os, int indent ) const {
-        using std::endl;
-        using std::string;
-
+void TypeData::print( ostream &os, int indent ) const {
         for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) {
                 if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' ';
@@ -326 +300 @@
                 break;
           case Aggregate:
-                os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << aggregate.name << endl;
+                os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl;
                 if ( aggregate.params ) {
                         os << string( indent + 2, ' ' ) << "with type parameters " << endl;
@@ -363 +337 @@
                 break;
           case SymbolicInst:
-                os << "instance of type " << symbolic.name;
+                os << "instance of type " << *symbolic.name;
                 if ( symbolic.actuals ) {
                         os << " with parameters" << endl;
@@ -389 +363 @@
                 } // if
                 break;
-          case Variable:
-                // os << DeclarationNode::typeClassName[ variable.tyClass ] << " variable ";
-                // if ( variable.assertions ) {
-                //      os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;
-                //      variable.assertions->printList( os, indent + 4 );
-                //      os << string( indent + 2, ' ' );
-                // } // if
-                break;
           case Tuple:
                 os << "tuple ";
@@ -410 +376 @@
                 } // if
                 break;
-          case Attr:
-                // os << "attribute type decl " << attr.name << " applied to ";
-                // if ( attr.expr ) {
-                //      attr.expr->print( os, indent + 2 );
-                // } // if
-                // if ( attr.type ) {
-                //      attr.type->print( os, indent + 2 );
-                // } // if
-                break;
           case Builtin:
                 os << "gcc builtin type";
@@ -428 +385 @@
 } // TypeData::print
 
-void buildForall( const DeclarationNode * firstNode, std::list< TypeDecl* > &outputList ) {
+void buildForall( const DeclarationNode * firstNode, list< TypeDecl* > &outputList ) {
         buildList( firstNode, outputList );
-        for ( std::list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
+        for ( list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
                 if ( (*i)->get_kind() == TypeDecl::Any ) {
                         // add assertion parameters to `type' tyvars in reverse order
                         // add dtor:  void ^?{}(T *)
                         FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
-                        dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
-                        (*i)->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, 0, false, false ) );
+                        dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
 
                         // add copy ctor:  void ?{}(T *, T)
                         FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
-                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
-                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
-                        (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, 0, false, false ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
 
                         // add default ctor:  void ?{}(T *)
                         FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
-                        ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
-                        (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, 0, false, false ) );
+                        ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
 
                         // add assignment operator:  T * ?=?(T *, T)
                         FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
-                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
-                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
-                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
-                        (*i)->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false, false ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
+                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
                 } // if
         } // for
@@ -486 +443 @@
           case TypeData::Builtin:
                 return new VarArgsType( buildQualifiers( td ) );
-          case TypeData::Attr:
-                assert( false );
-                return buildAttr( td );
           case TypeData::Symbolic:
           case TypeData::Enum:
           case TypeData::Aggregate:
-          case TypeData::Variable:
                 assert( false );
         } // switch
-        return 0;
+        return nullptr;
 } // typebuild
 
 TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) {
-        TypeData * ret = 0;
+        TypeData * ret = nullptr;
 
         switch ( td->kind ) {
@@ -549 +502 @@
           case DeclarationNode::Bool:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
                 } // if
                 if ( td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
                 } // if
 
@@ -565 +518 @@
 
                 if ( td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
                 } // if
 
@@ -595 +548 @@
           FloatingPoint: ;
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
                 } // if
                 if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
-                        throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
                 } // if
                 if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
@@ -655 +608 @@
         switch ( td->aggregate.kind ) {
           case DeclarationNode::Struct:
-                at = new StructDecl( td->aggregate.name );
+                at = new StructDecl( *td->aggregate.name );
                 buildForall( td->aggregate.params, at->get_parameters() );
                 break;
           case DeclarationNode::Union:
-                at = new UnionDecl( td->aggregate.name );
+                at = new UnionDecl( *td->aggregate.name );
                 buildForall( td->aggregate.params, at->get_parameters() );
                 break;
           case DeclarationNode::Trait:
-                at = new TraitDecl( td->aggregate.name );
+                at = new TraitDecl( *td->aggregate.name );
                 buildList( td->aggregate.params, at->get_parameters() );
                 break;
@@ -681 +634 @@
         ReferenceToType * ret;
         if ( td->aggInst.aggregate->kind == TypeData::Enum ) {
-                ret = new EnumInstType( buildQualifiers( td ), td->aggInst.aggregate->enumeration.name );
+                ret = new EnumInstType( buildQualifiers( td ), *td->aggInst.aggregate->enumeration.name );
         } else {
                 assert( td->aggInst.aggregate->kind == TypeData::Aggregate );
                 switch ( td->aggInst.aggregate->aggregate.kind ) {
                   case DeclarationNode::Struct:
-                        ret = new StructInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
+                        assert( td->aggInst.aggregate->aggregate.name );
+                        ret = new StructInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
                         break;
                   case DeclarationNode::Union:
-                        ret = new UnionInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
+                        ret = new UnionInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
                         break;
                   case DeclarationNode::Trait:
-                        ret = new TraitInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
+                        ret = new TraitInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
                         break;
                   default:
@@ -703 +657 @@
 } // buildAggInst
 
-NamedTypeDecl * buildSymbolic( const TypeData * td, const std::string & name, DeclarationNode::StorageClass sc ) {
+NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClass sc ) {
         assert( td->kind == TypeData::Symbolic );
         NamedTypeDecl * ret;
@@ -717 +671 @@
 } // buildSymbolic
 
-TypeDecl * buildVariable( const TypeData * td ) {
-        assert( false );
-        return nullptr;
-        // assert( td->kind == TypeData::Variable );
-        // static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
-
-        // TypeDecl * ret = new TypeDecl( td->variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ td->variable.tyClass ] );
-        // buildList( td->variable.assertions, ret->get_assertions() );
-        // return ret;
-} // buildSymbolic
-
 EnumDecl * buildEnum( const TypeData * td ) {
         assert( td->kind == TypeData::Enum );
-        EnumDecl * ret = new EnumDecl( td->enumeration.name );
+        EnumDecl * ret = new EnumDecl( *td->enumeration.name );
         buildList( td->enumeration.constants, ret->get_members() );
-        std::list< Declaration * >::iterator members = ret->get_members().begin();
+        list< Declaration * >::iterator members = ret->get_members().begin();
         for ( const DeclarationNode * cur = td->enumeration. constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
                 if ( cur->has_enumeratorValue() ) {
                         ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
-                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), std::list< Expression * >() ) );
+                        member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) );
                 } // if
         } // for
@@ -744 +687 @@
 TypeInstType * buildSymbolicInst( const TypeData * td ) {
         assert( td->kind == TypeData::SymbolicInst );
-        TypeInstType * ret = new TypeInstType( buildQualifiers( td ), td->symbolic.name, false );
+        TypeInstType * ret = new TypeInstType( buildQualifiers( td ), *td->symbolic.name, false );
         buildList( td->symbolic.actuals, ret->get_parameters() );
         buildForall( td->forall, ret->get_forall() );
@@ -765 +708 @@
 } // buildTypeof
 
-AttrType * buildAttr( const TypeData * td ) {
-        assert( false );
-        return nullptr;
-        // assert( td->kind == TypeData::Attr );
-        // // assert( td->attr );
-        // AttrType * ret;
-        // if ( td->attr.expr ) {
-        //      ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.expr->build() );
-        // } else {
-        //      assert( td->attr.type );
-        //      ret = new AttrType( buildQualifiers( td ), td->attr.name, td->attr.type->buildType() );
-        // } // if
-        // return ret;
-} // buildAttr
-
-Declaration * buildDecl( const TypeData * td, std::string name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) {
+Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) {
         if ( td->kind == TypeData::Function ) {
                 FunctionDecl * decl;
@@ -790 +718 @@
                                 decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn );
                         } else {
-                                // std::list< Label > ls;
-                                decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( std::list< Label >() ), isInline, isNoreturn );
+                                // list< Label > ls;
+                                decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( list< Label >() ), isInline, isNoreturn );
                         } // if
                 } else {
-                        decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), 0, isInline, isNoreturn );
-                } // if
-                for ( DeclarationNode * cur = td->function.idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {
-                        if ( cur->get_name() != "" ) {
-                                decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() );
+                        decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), nullptr, isInline, isNoreturn );
+                } // if
+                for ( DeclarationNode * cur = td->function.idList; cur != nullptr; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {
+                        if ( cur->name ) {
+                                decl->get_oldIdents().insert( decl->get_oldIdents().end(), *cur->name );
                         } // if
                 } // for
@@ -809 +737 @@
         } else if ( td->kind == TypeData::Symbolic ) {
                 return buildSymbolic( td, name, sc );
-        } else if ( td->kind == TypeData::Variable ) {
-                assert( false );
-                return buildVariable( td );
         } else {
-                return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, std::list< Attribute * >(), isInline, isNoreturn );
+                return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, list< Attribute * >(), isInline, isNoreturn );
         } // if
-        return 0;
+        return nullptr;
 } // buildDecl
 
@@ -831 +756 @@
                         break;
                   default:
-                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, 0, false, false, LinkageSpec::Cforall ) ) );
+                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall ) ) );
                 } // switch
         } else {
-                ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) );
+                ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
         } // if
         return ft;

src/Parser/TypeData.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 12 17:15:49 2016
-// Update Count     : 129
+// Last Modified On : Sat Sep 24 11:10:38 2016
+// Update Count     : 141
 //
 
@@ -24 +24 @@
 struct TypeData {
         enum Kind { Unknown, Basic, Pointer, Array, Function, Aggregate, AggregateInst,
-                                Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr };
+                                Enum, EnumConstant, Symbolic, SymbolicInst, Tuple, Typeof, Builtin };
 
         struct Aggregate_t {
                 DeclarationNode::Aggregate kind;
-                std::string name;
+                const std::string * name;
                 DeclarationNode * params;
-                ExpressionNode  * actuals;                                              // holds actual parameters later applied to AggInst
+                ExpressionNode * actuals;                                               // holds actual parameters later applied to AggInst
                 DeclarationNode * fields;
                 bool body;
@@ -47 +47 @@
 
         struct Enumeration_t {
-                std::string name;
+                const std::string * name;
                 DeclarationNode * constants;
         };
@@ -61 +61 @@
 
         struct Symbolic_t {
-                std::string name;
+                const std::string * name;
                 bool isTypedef;                                                                 // false => TYPEGENname, true => TYPEDEFname
                 DeclarationNode * params;
@@ -88 +88 @@
                 DeclarationNode * tuple;
                 ExpressionNode * typeexpr;
-                // Attr_t attr;
                 // DeclarationNode::BuiltinType builtin;
 
@@ -111 +110 @@
 TupleType * buildTuple( const TypeData * );
 TypeofType * buildTypeof( const TypeData * );
-AttrType * buildAttr( const TypeData * );
-Declaration * buildDecl( const TypeData *, std::string, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = 0 );
+Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = nullptr );
 FunctionType * buildFunction( const TypeData * );
 

src/Parser/parser.cc

@@ -82 +82 @@
 #include "TypeData.h"
 #include "LinkageSpec.h"
+using namespace std;
 
 extern DeclarationNode * parseTree;
@@ -87 +88 @@
 extern TypedefTable typedefTable;
 
-std::stack< LinkageSpec::Spec > linkageStack;
-
-void appendStr( std::string *to, std::string *from ) {
+stack< LinkageSpec::Spec > linkageStack;
+
+void appendStr( string *to, string *from ) {
         // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
         to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) );
@@ -96 +97 @@
 
 /* Line 268 of yacc.c  */
-#line 99 "Parser/parser.cc"
+#line 100 "Parser/parser.cc"
 
 /* Enabling traces.  */
@@ -347 +348 @@
 
 /* Line 293 of yacc.c  */
-#line 115 "parser.yy"
+#line 116 "parser.yy"
 
         Token tok;
@@ -367 +368 @@
 
 /* Line 293 of yacc.c  */
-#line 370 "Parser/parser.cc"
+#line 371 "Parser/parser.cc"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
@@ -379 +380 @@
 
 /* Line 343 of yacc.c  */
-#line 382 "Parser/parser.cc"
+#line 383 "Parser/parser.cc"
 
 #ifdef short
@@ -1021 +1022 @@
 static const yytype_uint16 yyrline[] =
 {
-       0,   300,   300,   304,   311,   312,   313,   317,   318,   319,
-     323,   324,   328,   329,   333,   334,   338,   342,   343,   354,
-     356,   358,   360,   365,   366,   372,   376,   378,   379,   381,
-     382,   384,   386,   388,   397,   398,   404,   405,   409,   410,
-     414,   418,   420,   422,   424,   429,   432,   434,   436,   441,
-     454,   456,   458,   460,   462,   464,   466,   468,   470,   472,
-     474,   481,   482,   488,   489,   490,   491,   495,   496,   498,
-     503,   504,   506,   508,   513,   514,   516,   521,   522,   524,
-     529,   530,   532,   534,   536,   541,   542,   544,   549,   550,
-     555,   556,   561,   562,   567,   568,   573,   574,   579,   580,
-     583,   585,   590,   595,   596,   598,   604,   605,   609,   610,
-     611,   612,   613,   614,   615,   616,   617,   618,   619,   620,
-     626,   628,   630,   632,   637,   638,   643,   644,   650,   651,
-     657,   658,   659,   660,   661,   662,   663,   664,   665,   675,
-     682,   684,   694,   695,   700,   702,   708,   710,   714,   715,
-     720,   725,   728,   730,   732,   742,   744,   755,   756,   758,
-     762,   764,   768,   769,   774,   775,   779,   784,   785,   789,
-     791,   797,   798,   802,   804,   806,   808,   814,   815,   819,
-     821,   826,   828,   830,   835,   837,   842,   844,   848,   851,
-     855,   858,   862,   864,   866,   868,   873,   875,   877,   882,
-     884,   886,   888,   890,   895,   897,   899,   901,   906,   918,
-     919,   924,   926,   931,   935,   937,   939,   941,   943,   949,
-     950,   956,   957,   961,   962,   967,   969,   975,   976,   978,
-     983,   988,   998,  1000,  1004,  1005,  1010,  1012,  1016,  1017,
-    1021,  1023,  1027,  1028,  1032,  1033,  1037,  1038,  1053,  1054,
-    1055,  1056,  1057,  1061,  1066,  1073,  1083,  1088,  1093,  1101,
-    1106,  1111,  1116,  1121,  1129,  1151,  1156,  1163,  1165,  1172,
-    1177,  1182,  1193,  1198,  1203,  1208,  1213,  1222,  1227,  1235,
-    1236,  1237,  1238,  1244,  1249,  1257,  1258,  1259,  1260,  1264,
-    1265,  1266,  1267,  1272,  1273,  1282,  1283,  1288,  1289,  1294,
-    1296,  1298,  1300,  1302,  1305,  1304,  1316,  1317,  1319,  1329,
-    1330,  1335,  1337,  1339,  1341,  1343,  1346,  1348,  1351,  1356,
-    1358,  1360,  1362,  1364,  1366,  1368,  1370,  1372,  1374,  1376,
-    1378,  1380,  1386,  1387,  1389,  1391,  1393,  1398,  1399,  1405,
-    1406,  1408,  1410,  1415,  1417,  1419,  1421,  1426,  1427,  1429,
-    1431,  1436,  1437,  1439,  1444,  1445,  1447,  1449,  1454,  1456,
-    1458,  1463,  1464,  1468,  1470,  1476,  1475,  1479,  1481,  1486,
-    1488,  1494,  1495,  1500,  1501,  1503,  1504,  1513,  1514,  1516,
-    1518,  1523,  1525,  1531,  1532,  1534,  1537,  1540,  1545,  1546,
-    1551,  1556,  1560,  1562,  1568,  1567,  1574,  1576,  1582,  1583,
-    1591,  1592,  1596,  1597,  1598,  1600,  1602,  1609,  1610,  1612,
-    1614,  1619,  1620,  1626,  1627,  1631,  1632,  1637,  1638,  1639,
-    1641,  1649,  1650,  1652,  1655,  1657,  1661,  1662,  1663,  1665,
-    1667,  1671,  1676,  1684,  1685,  1694,  1696,  1701,  1702,  1703,
-    1707,  1708,  1709,  1713,  1714,  1715,  1719,  1720,  1721,  1726,
-    1727,  1728,  1729,  1735,  1736,  1738,  1743,  1744,  1749,  1750,
-    1751,  1752,  1753,  1768,  1769,  1774,  1775,  1781,  1783,  1786,
-    1788,  1790,  1813,  1814,  1816,  1818,  1823,  1824,  1826,  1831,
-    1836,  1837,  1843,  1842,  1846,  1850,  1852,  1854,  1860,  1861,
-    1866,  1871,  1873,  1878,  1880,  1881,  1883,  1888,  1890,  1892,
-    1897,  1899,  1904,  1909,  1917,  1923,  1922,  1936,  1937,  1942,
-    1943,  1947,  1952,  1957,  1965,  1970,  1981,  1982,  1987,  1988,
-    1994,  1995,  1999,  2000,  2001,  2004,  2003,  2014,  2023,  2029,
-    2035,  2044,  2050,  2056,  2062,  2068,  2076,  2082,  2090,  2096,
-    2105,  2106,  2107,  2111,  2115,  2117,  2122,  2123,  2127,  2128,
-    2133,  2139,  2140,  2143,  2145,  2146,  2150,  2151,  2152,  2153,
-    2187,  2189,  2190,  2192,  2197,  2202,  2207,  2209,  2211,  2216,
-    2218,  2220,  2222,  2227,  2229,  2238,  2240,  2241,  2246,  2248,
-    2250,  2255,  2257,  2259,  2264,  2266,  2268,  2277,  2278,  2279,
-    2283,  2285,  2287,  2292,  2294,  2296,  2301,  2303,  2305,  2320,
-    2322,  2323,  2325,  2330,  2331,  2336,  2338,  2340,  2345,  2347,
-    2349,  2351,  2356,  2358,  2360,  2370,  2372,  2373,  2375,  2380,
-    2382,  2384,  2389,  2391,  2393,  2395,  2400,  2402,  2404,  2435,
-    2437,  2438,  2440,  2445,  2450,  2458,  2460,  2462,  2467,  2469,
-    2474,  2476,  2490,  2491,  2493,  2498,  2500,  2502,  2504,  2506,
-    2511,  2512,  2514,  2516,  2521,  2523,  2525,  2531,  2533,  2535,
-    2539,  2541,  2543,  2545,  2559,  2560,  2562,  2567,  2569,  2571,
-    2573,  2575,  2580,  2581,  2583,  2585,  2590,  2592,  2594,  2600,
-    2601,  2603,  2612,  2615,  2617,  2620,  2622,  2624,  2637,  2638,
-    2640,  2645,  2647,  2649,  2651,  2653,  2658,  2659,  2661,  2663,
-    2668,  2670,  2678,  2679,  2680,  2685,  2686,  2690,  2692,  2694,
-    2696,  2698,  2700,  2707,  2709,  2711,  2713,  2715,  2717,  2719,
-    2721,  2723,  2725,  2730,  2732,  2734,  2739,  2765,  2766,  2768,
-    2772,  2773,  2777,  2779,  2781,  2783,  2785,  2787,  2794,  2796,
-    2798,  2800,  2802,  2804,  2809,  2814,  2816,  2818,  2836,  2838,
-    2843,  2844
+       0,   301,   301,   305,   312,   313,   314,   318,   319,   320,
+     324,   325,   329,   330,   334,   335,   339,   343,   344,   355,
+     357,   359,   361,   366,   367,   373,   377,   379,   380,   382,
+     383,   385,   387,   389,   398,   399,   405,   406,   410,   411,
+     415,   419,   421,   423,   425,   430,   433,   435,   437,   442,
+     455,   457,   459,   461,   463,   465,   467,   469,   471,   473,
+     475,   482,   483,   489,   490,   491,   492,   496,   497,   499,
+     504,   505,   507,   509,   514,   515,   517,   522,   523,   525,
+     530,   531,   533,   535,   537,   542,   543,   545,   550,   551,
+     556,   557,   562,   563,   568,   569,   574,   575,   580,   581,
+     584,   586,   591,   596,   597,   599,   605,   606,   610,   611,
+     612,   613,   614,   615,   616,   617,   618,   619,   620,   621,
+     627,   629,   631,   633,   638,   639,   644,   645,   651,   652,
+     658,   659,   660,   661,   662,   663,   664,   665,   666,   676,
+     683,   685,   695,   696,   701,   703,   709,   711,   715,   716,
+     721,   726,   729,   731,   733,   743,   745,   756,   757,   759,
+     763,   765,   769,   770,   775,   776,   780,   785,   786,   790,
+     792,   798,   799,   803,   805,   807,   809,   815,   816,   820,
+     822,   827,   829,   831,   836,   838,   843,   845,   849,   852,
+     856,   859,   863,   865,   867,   869,   874,   876,   878,   883,
+     885,   887,   889,   891,   896,   898,   900,   902,   907,   919,
+     920,   925,   927,   932,   936,   938,   940,   942,   944,   950,
+     951,   957,   958,   962,   963,   968,   970,   976,   977,   979,
+     984,   989,   999,  1001,  1005,  1006,  1011,  1013,  1017,  1018,
+    1022,  1024,  1028,  1029,  1033,  1034,  1038,  1039,  1054,  1055,
+    1056,  1057,  1058,  1062,  1067,  1074,  1084,  1089,  1094,  1102,
+    1107,  1112,  1117,  1122,  1130,  1152,  1157,  1164,  1166,  1173,
+    1178,  1183,  1194,  1199,  1204,  1209,  1214,  1223,  1228,  1236,
+    1237,  1238,  1239,  1245,  1250,  1258,  1259,  1260,  1261,  1265,
+    1266,  1267,  1268,  1273,  1274,  1283,  1284,  1289,  1290,  1295,
+    1297,  1299,  1301,  1303,  1306,  1305,  1317,  1318,  1320,  1330,
+    1331,  1336,  1338,  1340,  1342,  1344,  1347,  1349,  1352,  1357,
+    1359,  1361,  1363,  1365,  1367,  1369,  1371,  1373,  1375,  1377,
+    1379,  1381,  1387,  1388,  1390,  1392,  1394,  1399,  1400,  1406,
+    1407,  1409,  1411,  1416,  1418,  1420,  1422,  1427,  1428,  1430,
+    1432,  1437,  1438,  1440,  1445,  1446,  1448,  1450,  1455,  1457,
+    1459,  1464,  1465,  1469,  1471,  1477,  1476,  1480,  1482,  1487,
+    1489,  1495,  1496,  1501,  1502,  1504,  1505,  1514,  1515,  1517,
+    1519,  1524,  1526,  1532,  1533,  1535,  1538,  1541,  1546,  1547,
+    1552,  1557,  1561,  1563,  1569,  1568,  1575,  1577,  1583,  1584,
+    1592,  1593,  1597,  1598,  1599,  1601,  1603,  1610,  1611,  1613,
+    1615,  1620,  1621,  1627,  1628,  1632,  1633,  1638,  1639,  1640,
+    1642,  1650,  1651,  1653,  1656,  1658,  1662,  1663,  1664,  1666,
+    1668,  1672,  1677,  1685,  1686,  1695,  1697,  1702,  1703,  1704,
+    1708,  1709,  1710,  1714,  1715,  1716,  1720,  1721,  1722,  1727,
+    1728,  1729,  1730,  1736,  1737,  1739,  1744,  1745,  1750,  1751,
+    1752,  1753,  1754,  1769,  1770,  1775,  1776,  1782,  1784,  1787,
+    1789,  1791,  1814,  1815,  1817,  1819,  1824,  1825,  1827,  1832,
+    1837,  1838,  1844,  1843,  1847,  1851,  1853,  1855,  1861,  1862,
+    1867,  1872,  1874,  1879,  1881,  1882,  1884,  1889,  1891,  1893,
+    1898,  1900,  1905,  1910,  1918,  1924,  1923,  1937,  1938,  1943,
+    1944,  1948,  1953,  1958,  1966,  1971,  1982,  1983,  1988,  1989,
+    1995,  1996,  2000,  2001,  2002,  2005,  2004,  2015,  2024,  2030,
+    2036,  2045,  2051,  2057,  2063,  2069,  2077,  2083,  2091,  2097,
+    2106,  2107,  2108,  2112,  2116,  2118,  2123,  2124,  2128,  2129,
+    2134,  2140,  2141,  2144,  2146,  2147,  2151,  2152,  2153,  2154,
+    2188,  2190,  2191,  2193,  2198,  2203,  2208,  2210,  2212,  2217,
+    2219,  2221,  2223,  2228,  2230,  2239,  2241,  2242,  2247,  2249,
+    2251,  2256,  2258,  2260,  2265,  2267,  2269,  2278,  2279,  2280,
+    2284,  2286,  2288,  2293,  2295,  2297,  2302,  2304,  2306,  2321,
+    2323,  2324,  2326,  2331,  2332,  2337,  2339,  2341,  2346,  2348,
+    2350,  2352,  2357,  2359,  2361,  2371,  2373,  2374,  2376,  2381,
+    2383,  2385,  2390,  2392,  2394,  2396,  2401,  2403,  2405,  2436,
+    2438,  2439,  2441,  2446,  2451,  2459,  2461,  2463,  2468,  2470,
+    2475,  2477,  2491,  2492,  2494,  2499,  2501,  2503,  2505,  2507,
+    2512,  2513,  2515,  2517,  2522,  2524,  2526,  2532,  2534,  2536,
+    2540,  2542,  2544,  2546,  2560,  2561,  2563,  2568,  2570,  2572,
+    2574,  2576,  2581,  2582,  2584,  2586,  2591,  2593,  2595,  2601,
+    2602,  2604,  2613,  2616,  2618,  2621,  2623,  2625,  2638,  2639,
+    2641,  2646,  2648,  2650,  2652,  2654,  2659,  2660,  2662,  2664,
+    2669,  2671,  2679,  2680,  2681,  2686,  2687,  2691,  2693,  2695,
+    2697,  2699,  2701,  2708,  2710,  2712,  2714,  2716,  2718,  2720,
+    2722,  2724,  2726,  2731,  2733,  2735,  2740,  2766,  2767,  2769,
+    2773,  2774,  2778,  2780,  2782,  2784,  2786,  2788,  2795,  2797,
+    2799,  2801,  2803,  2805,  2810,  2815,  2817,  2819,  2837,  2839,
+    2844,  2845
 };
 #endif
@@ -4971 +4972 @@
 
 /* Line 1806 of yacc.c  */
-#line 300 "parser.yy"
+#line 301 "parser.yy"
     { typedefTable.enterScope(); }
     break;
@@ -4978 +4979 @@
 
 /* Line 1806 of yacc.c  */
-#line 304 "parser.yy"
+#line 305 "parser.yy"
     { typedefTable.leaveScope(); }
     break;
@@ -4985 +4986 @@
 
 /* Line 1806 of yacc.c  */
-#line 311 "parser.yy"
+#line 312 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -4992 +4993 @@
 
 /* Line 1806 of yacc.c  */
-#line 312 "parser.yy"
+#line 313 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -4999 +5000 @@
 
 /* Line 1806 of yacc.c  */
-#line 313 "parser.yy"
+#line 314 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_constantChar( *(yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -5006 +5007 @@
 
 /* Line 1806 of yacc.c  */
-#line 338 "parser.yy"
+#line 339 "parser.yy"
     { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].str) ); }
     break;
@@ -5013 +5014 @@
 
 /* Line 1806 of yacc.c  */
-#line 342 "parser.yy"
+#line 343 "parser.yy"
     { (yyval.str) = (yyvsp[(1) - (1)].tok); }
     break;
@@ -5020 +5021 @@
 
 /* Line 1806 of yacc.c  */
-#line 344 "parser.yy"
+#line 345 "parser.yy"
     {
                         appendStr( (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].tok) );                                            // append 2nd juxtaposed string to 1st
@@ -5031 +5032 @@
 
 /* Line 1806 of yacc.c  */
-#line 355 "parser.yy"
+#line 356 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -5038 +5039 @@
 
 /* Line 1806 of yacc.c  */
-#line 357 "parser.yy"
+#line 358 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -5045 +5046 @@
 
 /* Line 1806 of yacc.c  */
-#line 359 "parser.yy"
+#line 360 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (3)].en); }
     break;
@@ -5052 +5053 @@
 
 /* Line 1806 of yacc.c  */
-#line 361 "parser.yy"
+#line 362 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_valexpr( (yyvsp[(2) - (3)].sn) ) ); }
     break;
@@ -5059 +5060 @@
 
 /* Line 1806 of yacc.c  */
-#line 371 "parser.yy"
+#line 372 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
     break;
@@ -5066 +5067 @@
 
 /* Line 1806 of yacc.c  */
-#line 373 "parser.yy"
+#line 374 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); }
     break;
@@ -5073 +5074 @@
 
 /* Line 1806 of yacc.c  */
-#line 377 "parser.yy"
+#line 378 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
     break;
@@ -5080 +5081 @@
 
 /* Line 1806 of yacc.c  */
-#line 380 "parser.yy"
+#line 381 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
     break;
@@ -5087 +5088 @@
 
 /* Line 1806 of yacc.c  */
-#line 383 "parser.yy"
+#line 384 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
     break;
@@ -5094 +5095 @@
 
 /* Line 1806 of yacc.c  */
-#line 385 "parser.yy"
+#line 386 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
     break;
@@ -5101 +5102 @@
 
 /* Line 1806 of yacc.c  */
-#line 387 "parser.yy"
+#line 388 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); }
     break;
@@ -5108 +5109 @@
 
 /* Line 1806 of yacc.c  */
-#line 389 "parser.yy"
+#line 390 "parser.yy"
     {
                         Token fn;
-                        fn.str = new std::string( "?{}" ); // location undefined - use location of '{'?
+                        fn.str = new std::string( "?{}" );                      // location undefined - use location of '{'?
                         (yyval.en) = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_last( (yyvsp[(3) - (4)].en) ) ) ) );
                 }
@@ -5119 +5120 @@
 
 /* Line 1806 of yacc.c  */
-#line 399 "parser.yy"
+#line 400 "parser.yy"
     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
     break;
@@ -5126 +5127 @@
 
 /* Line 1806 of yacc.c  */
-#line 404 "parser.yy"
+#line 405 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -5133 +5134 @@
 
 /* Line 1806 of yacc.c  */
-#line 410 "parser.yy"
+#line 411 "parser.yy"
     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
     break;
@@ -5140 +5141 @@
 
 /* Line 1806 of yacc.c  */
-#line 415 "parser.yy"
+#line 416 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -5147 +5148 @@
 
 /* Line 1806 of yacc.c  */
-#line 419 "parser.yy"
+#line 420 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
     break;
@@ -5154 +5155 @@
 
 /* Line 1806 of yacc.c  */
-#line 421 "parser.yy"
+#line 422 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
     break;
@@ -5161 +5162 @@
 
 /* Line 1806 of yacc.c  */
-#line 423 "parser.yy"
+#line 424 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
     break;
@@ -5168 +5169 @@
 
 /* Line 1806 of yacc.c  */
-#line 425 "parser.yy"
+#line 426 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
     break;
@@ -5175 +5176 @@
 
 /* Line 1806 of yacc.c  */
-#line 433 "parser.yy"
+#line 434 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
@@ -5182 +5183 @@
 
 /* Line 1806 of yacc.c  */
-#line 435 "parser.yy"
+#line 436 "parser.yy"
     { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
     break;
@@ -5189 +5190 @@
 
 /* Line 1806 of yacc.c  */
-#line 437 "parser.yy"
+#line 438 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
     break;
@@ -5196 +5197 @@
 
 /* Line 1806 of yacc.c  */
-#line 442 "parser.yy"
+#line 443 "parser.yy"
     {
                         switch ( (yyvsp[(1) - (2)].op) ) {
@@ -5214 +5215 @@
 
 /* Line 1806 of yacc.c  */
-#line 455 "parser.yy"
+#line 456 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -5221 +5222 @@
 
 /* Line 1806 of yacc.c  */
-#line 457 "parser.yy"
+#line 458 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -5228 +5229 @@
 
 /* Line 1806 of yacc.c  */
-#line 459 "parser.yy"
+#line 460 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -5235 +5236 @@
 
 /* Line 1806 of yacc.c  */
-#line 461 "parser.yy"
+#line 462 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -5242 +5243 @@
 
 /* Line 1806 of yacc.c  */
-#line 463 "parser.yy"
+#line 464 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); }
     break;
@@ -5249 +5250 @@
 
 /* Line 1806 of yacc.c  */
-#line 465 "parser.yy"
+#line 466 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -5256 +5257 @@
 
 /* Line 1806 of yacc.c  */
-#line 467 "parser.yy"
+#line 468 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); }
     break;
@@ -5263 +5264 @@
 
 /* Line 1806 of yacc.c  */
-#line 469 "parser.yy"
+#line 470 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); }
     break;
@@ -5270 +5271 @@
 
 /* Line 1806 of yacc.c  */
-#line 471 "parser.yy"
+#line 472 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); }
     break;
@@ -5277 +5278 @@
 
 /* Line 1806 of yacc.c  */
-#line 473 "parser.yy"
+#line 474 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
     break;
@@ -5284 +5285 @@
 
 /* Line 1806 of yacc.c  */
-#line 475 "parser.yy"
+#line 476 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); }
     break;
@@ -5291 +5292 @@
 
 /* Line 1806 of yacc.c  */
-#line 481 "parser.yy"
+#line 482 "parser.yy"
     { (yyval.op) = OperKinds::PointTo; }
     break;
@@ -5298 +5299 @@
 
 /* Line 1806 of yacc.c  */
-#line 482 "parser.yy"
+#line 483 "parser.yy"
     { (yyval.op) = OperKinds::AddressOf; }
     break;
@@ -5305 +5306 @@
 
 /* Line 1806 of yacc.c  */
-#line 488 "parser.yy"
+#line 489 "parser.yy"
     { (yyval.op) = OperKinds::UnPlus; }
     break;
@@ -5312 +5313 @@
 
 /* Line 1806 of yacc.c  */
-#line 489 "parser.yy"
+#line 490 "parser.yy"
     { (yyval.op) = OperKinds::UnMinus; }
     break;
@@ -5319 +5320 @@
 
 /* Line 1806 of yacc.c  */
-#line 490 "parser.yy"
+#line 491 "parser.yy"
     { (yyval.op) = OperKinds::Neg; }
     break;
@@ -5326 +5327 @@
 
 /* Line 1806 of yacc.c  */
-#line 491 "parser.yy"
+#line 492 "parser.yy"
     { (yyval.op) = OperKinds::BitNeg; }
     break;
@@ -5333 +5334 @@
 
 /* Line 1806 of yacc.c  */
-#line 497 "parser.yy"
+#line 498 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
     break;
@@ -5340 +5341 @@
 
 /* Line 1806 of yacc.c  */
-#line 499 "parser.yy"
+#line 500 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
     break;
@@ -5347 +5348 @@
 
 /* Line 1806 of yacc.c  */
-#line 505 "parser.yy"
+#line 506 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5354 +5355 @@
 
 /* Line 1806 of yacc.c  */
-#line 507 "parser.yy"
+#line 508 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5361 +5362 @@
 
 /* Line 1806 of yacc.c  */
-#line 509 "parser.yy"
+#line 510 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5368 +5369 @@
 
 /* Line 1806 of yacc.c  */
-#line 515 "parser.yy"
+#line 516 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5375 +5376 @@
 
 /* Line 1806 of yacc.c  */
-#line 517 "parser.yy"
+#line 518 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5382 +5383 @@
 
 /* Line 1806 of yacc.c  */
-#line 523 "parser.yy"
+#line 524 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5389 +5390 @@
 
 /* Line 1806 of yacc.c  */
-#line 525 "parser.yy"
+#line 526 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5396 +5397 @@
 
 /* Line 1806 of yacc.c  */
-#line 531 "parser.yy"
+#line 532 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5403 +5404 @@
 
 /* Line 1806 of yacc.c  */
-#line 533 "parser.yy"
+#line 534 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5410 +5411 @@
 
 /* Line 1806 of yacc.c  */
-#line 535 "parser.yy"
+#line 536 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5417 +5418 @@
 
 /* Line 1806 of yacc.c  */
-#line 537 "parser.yy"
+#line 538 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5424 +5425 @@
 
 /* Line 1806 of yacc.c  */
-#line 543 "parser.yy"
+#line 544 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5431 +5432 @@
 
 /* Line 1806 of yacc.c  */
-#line 545 "parser.yy"
+#line 546 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5438 +5439 @@
 
 /* Line 1806 of yacc.c  */
-#line 551 "parser.yy"
+#line 552 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5445 +5446 @@
 
 /* Line 1806 of yacc.c  */
-#line 557 "parser.yy"
+#line 558 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5452 +5453 @@
 
 /* Line 1806 of yacc.c  */
-#line 563 "parser.yy"
+#line 564 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5459 +5460 @@
 
 /* Line 1806 of yacc.c  */
-#line 569 "parser.yy"
+#line 570 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
     break;
@@ -5466 +5467 @@
 
 /* Line 1806 of yacc.c  */
-#line 575 "parser.yy"
+#line 576 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
     break;
@@ -5473 +5474 @@
 
 /* Line 1806 of yacc.c  */
-#line 581 "parser.yy"
+#line 582 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     break;
@@ -5480 +5481 @@
 
 /* Line 1806 of yacc.c  */
-#line 584 "parser.yy"
+#line 585 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
     break;
@@ -5487 +5488 @@
 
 /* Line 1806 of yacc.c  */
-#line 586 "parser.yy"
+#line 587 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     break;
@@ -5494 +5495 @@
 
 /* Line 1806 of yacc.c  */
-#line 597 "parser.yy"
+#line 598 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5501 +5502 @@
 
 /* Line 1806 of yacc.c  */
-#line 599 "parser.yy"
+#line 600 "parser.yy"
     { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new ExpressionNode( build_binary_ptr( OperKinds::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); }
     break;
@@ -5508 +5509 @@
 
 /* Line 1806 of yacc.c  */
-#line 604 "parser.yy"
+#line 605 "parser.yy"
     { (yyval.en) = nullptr; }
     break;
@@ -5515 +5516 @@
 
 /* Line 1806 of yacc.c  */
-#line 609 "parser.yy"
+#line 610 "parser.yy"
     { (yyval.op) = OperKinds::Assign; }
     break;
@@ -5522 +5523 @@
 
 /* Line 1806 of yacc.c  */
-#line 610 "parser.yy"
+#line 611 "parser.yy"
     { (yyval.op) = OperKinds::AtAssn; }
     break;
@@ -5529 +5530 @@
 
 /* Line 1806 of yacc.c  */
-#line 611 "parser.yy"
+#line 612 "parser.yy"
     { (yyval.op) = OperKinds::MulAssn; }
     break;
@@ -5536 +5537 @@
 
 /* Line 1806 of yacc.c  */
-#line 612 "parser.yy"
+#line 613 "parser.yy"
     { (yyval.op) = OperKinds::DivAssn; }
     break;
@@ -5543 +5544 @@
 
 /* Line 1806 of yacc.c  */
-#line 613 "parser.yy"
+#line 614 "parser.yy"
     { (yyval.op) = OperKinds::ModAssn; }
     break;
@@ -5550 +5551 @@
 
 /* Line 1806 of yacc.c  */
-#line 614 "parser.yy"
+#line 615 "parser.yy"
     { (yyval.op) = OperKinds::PlusAssn; }
     break;
@@ -5557 +5558 @@
 
 /* Line 1806 of yacc.c  */
-#line 615 "parser.yy"
+#line 616 "parser.yy"
     { (yyval.op) = OperKinds::MinusAssn; }
     break;
@@ -5564 +5565 @@
 
 /* Line 1806 of yacc.c  */
-#line 616 "parser.yy"
+#line 617 "parser.yy"
     { (yyval.op) = OperKinds::LSAssn; }
     break;
@@ -5571 +5572 @@
 
 /* Line 1806 of yacc.c  */
-#line 617 "parser.yy"
+#line 618 "parser.yy"
     { (yyval.op) = OperKinds::RSAssn; }
     break;
@@ -5578 +5579 @@
 
 /* Line 1806 of yacc.c  */
-#line 618 "parser.yy"
+#line 619 "parser.yy"
     { (yyval.op) = OperKinds::AndAssn; }
     break;
@@ -5585 +5586 @@
 
 /* Line 1806 of yacc.c  */
-#line 619 "parser.yy"
+#line 620 "parser.yy"
     { (yyval.op) = OperKinds::ERAssn; }
     break;
@@ -5592 +5593 @@
 
 /* Line 1806 of yacc.c  */
-#line 620 "parser.yy"
+#line 621 "parser.yy"
     { (yyval.op) = OperKinds::OrAssn; }
     break;
@@ -5599 +5600 @@
 
 /* Line 1806 of yacc.c  */
-#line 627 "parser.yy"
+#line 628 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_tuple() ); }
     break;
@@ -5606 +5607 @@
 
 /* Line 1806 of yacc.c  */
-#line 629 "parser.yy"
+#line 630 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); }
     break;
@@ -5613 +5614 @@
 
 /* Line 1806 of yacc.c  */
-#line 631 "parser.yy"
+#line 632 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); }
     break;
@@ -5620 +5621 @@
 
 /* Line 1806 of yacc.c  */
-#line 633 "parser.yy"
+#line 634 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); }
     break;
@@ -5627 +5628 @@
 
 /* Line 1806 of yacc.c  */
-#line 639 "parser.yy"
+#line 640 "parser.yy"
     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
     break;
@@ -5634 +5635 @@
 
 /* Line 1806 of yacc.c  */
-#line 645 "parser.yy"
+#line 646 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5641 +5642 @@
 
 /* Line 1806 of yacc.c  */
-#line 650 "parser.yy"
+#line 651 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -5648 +5649 @@
 
 /* Line 1806 of yacc.c  */
-#line 659 "parser.yy"
+#line 660 "parser.yy"
     { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
     break;
@@ -5655 +5656 @@
 
 /* Line 1806 of yacc.c  */
-#line 666 "parser.yy"
+#line 667 "parser.yy"
     {
                         Token fn;
-                        fn.str = new std::string( "^?{}" ); // location undefined
+                        fn.str = new string( "^?{}" );                          // location undefined
                         (yyval.sn) = new StatementNode( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(2) - (6)].en) )->set_last( (yyvsp[(4) - (6)].en) ) ) ) ) );
                 }
@@ -5666 +5667 @@
 
 /* Line 1806 of yacc.c  */
-#line 676 "parser.yy"
+#line 677 "parser.yy"
     {
                         (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
@@ -5675 +5676 @@
 
 /* Line 1806 of yacc.c  */
-#line 683 "parser.yy"
+#line 684 "parser.yy"
     { (yyval.sn) = new StatementNode( build_compound( (StatementNode *)0 ) ); }
     break;
@@ -5682 +5683 @@
 
 /* Line 1806 of yacc.c  */
-#line 690 "parser.yy"
+#line 691 "parser.yy"
     { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); }
     break;
@@ -5689 +5690 @@
 
 /* Line 1806 of yacc.c  */
-#line 696 "parser.yy"
+#line 697 "parser.yy"
     { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
     break;
@@ -5696 +5697 @@
 
 /* Line 1806 of yacc.c  */
-#line 701 "parser.yy"
+#line 702 "parser.yy"
     { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
     break;
@@ -5703 +5704 @@
 
 /* Line 1806 of yacc.c  */
-#line 703 "parser.yy"
+#line 704 "parser.yy"
     {   // mark all fields in list
                         for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
@@ -5714 +5715 @@
 
 /* Line 1806 of yacc.c  */
-#line 709 "parser.yy"
+#line 710 "parser.yy"
     { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
     break;
@@ -5721 +5722 @@
 
 /* Line 1806 of yacc.c  */
-#line 716 "parser.yy"
+#line 717 "parser.yy"
     { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
     break;
@@ -5728 +5729 @@
 
 /* Line 1806 of yacc.c  */
-#line 721 "parser.yy"
+#line 722 "parser.yy"
     { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); }
     break;
@@ -5735 +5736 @@
 
 /* Line 1806 of yacc.c  */
-#line 727 "parser.yy"
+#line 728 "parser.yy"
     { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); }
     break;
@@ -5742 +5743 @@
 
 /* Line 1806 of yacc.c  */
-#line 729 "parser.yy"
+#line 730 "parser.yy"
     { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); }
     break;
@@ -5749 +5750 @@
 
 /* Line 1806 of yacc.c  */
-#line 731 "parser.yy"
+#line 732 "parser.yy"
     { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
     break;
@@ -5756 +5757 @@
 
 /* Line 1806 of yacc.c  */
-#line 733 "parser.yy"
+#line 734 "parser.yy"
     {
                         StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
@@ -5771 +5772 @@
 
 /* Line 1806 of yacc.c  */
-#line 743 "parser.yy"
+#line 744 "parser.yy"
     { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
     break;
@@ -5778 +5779 @@
 
 /* Line 1806 of yacc.c  */
-#line 745 "parser.yy"
+#line 746 "parser.yy"
     {
                         StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
@@ -5788 +5789 @@
 
 /* Line 1806 of yacc.c  */
-#line 755 "parser.yy"
+#line 756 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
@@ -5795 +5796 @@
 
 /* Line 1806 of yacc.c  */
-#line 757 "parser.yy"
+#line 758 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5802 +5803 @@
 
 /* Line 1806 of yacc.c  */
-#line 762 "parser.yy"
+#line 763 "parser.yy"
     { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); }
     break;
@@ -5809 +5810 @@
 
 /* Line 1806 of yacc.c  */
-#line 764 "parser.yy"
+#line 765 "parser.yy"
     { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
     break;
@@ -5816 +5817 @@
 
 /* Line 1806 of yacc.c  */
-#line 768 "parser.yy"
+#line 769 "parser.yy"
     { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
     break;
@@ -5823 +5824 @@
 
 /* Line 1806 of yacc.c  */
-#line 769 "parser.yy"
+#line 770 "parser.yy"
     { (yyval.sn) = new StatementNode( build_default() ); }
     break;
@@ -5830 +5831 @@
 
 /* Line 1806 of yacc.c  */
-#line 775 "parser.yy"
+#line 776 "parser.yy"
     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); }
     break;
@@ -5837 +5838 @@
 
 /* Line 1806 of yacc.c  */
-#line 779 "parser.yy"
+#line 780 "parser.yy"
     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
     break;
@@ -5844 +5845 @@
 
 /* Line 1806 of yacc.c  */
-#line 784 "parser.yy"
+#line 785 "parser.yy"
     { (yyval.sn) = 0; }
     break;
@@ -5851 +5852 @@
 
 /* Line 1806 of yacc.c  */
-#line 790 "parser.yy"
+#line 791 "parser.yy"
     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
     break;
@@ -5858 +5859 @@
 
 /* Line 1806 of yacc.c  */
-#line 792 "parser.yy"
+#line 793 "parser.yy"
     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); }
     break;
@@ -5865 +5866 @@
 
 /* Line 1806 of yacc.c  */
-#line 797 "parser.yy"
+#line 798 "parser.yy"
     { (yyval.sn) = 0; }
     break;
@@ -5872 +5873 @@
 
 /* Line 1806 of yacc.c  */
-#line 803 "parser.yy"
+#line 804 "parser.yy"
     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
     break;
@@ -5879 +5880 @@
 
 /* Line 1806 of yacc.c  */
-#line 805 "parser.yy"
+#line 806 "parser.yy"
     { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); }
     break;
@@ -5886 +5887 @@
 
 /* Line 1806 of yacc.c  */
-#line 807 "parser.yy"
+#line 808 "parser.yy"
     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
     break;
@@ -5893 +5894 @@
 
 /* Line 1806 of yacc.c  */
-#line 809 "parser.yy"
+#line 810 "parser.yy"
     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_last( (yyvsp[(2) - (4)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(3) - (4)].sn)->set_last( (yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
     break;
@@ -5900 +5901 @@
 
 /* Line 1806 of yacc.c  */
-#line 814 "parser.yy"
+#line 815 "parser.yy"
     { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
     break;
@@ -5907 +5908 @@
 
 /* Line 1806 of yacc.c  */
-#line 820 "parser.yy"
+#line 821 "parser.yy"
     { (yyval.sn) = 0; }
     break;
@@ -5914 +5915 @@
 
 /* Line 1806 of yacc.c  */
-#line 822 "parser.yy"
+#line 823 "parser.yy"
     { (yyval.sn) = 0; }
     break;
@@ -5921 +5922 @@
 
 /* Line 1806 of yacc.c  */
-#line 827 "parser.yy"
+#line 828 "parser.yy"
     { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
     break;
@@ -5928 +5929 @@
 
 /* Line 1806 of yacc.c  */
-#line 829 "parser.yy"
+#line 830 "parser.yy"
     { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); }
     break;
@@ -5935 +5936 @@
 
 /* Line 1806 of yacc.c  */
-#line 831 "parser.yy"
+#line 832 "parser.yy"
     { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
     break;
@@ -5942 +5943 @@
 
 /* Line 1806 of yacc.c  */
-#line 836 "parser.yy"
+#line 837 "parser.yy"
     { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
     break;
@@ -5949 +5950 @@
 
 /* Line 1806 of yacc.c  */
-#line 838 "parser.yy"
+#line 839 "parser.yy"
     { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
     break;
@@ -5956 +5957 @@
 
 /* Line 1806 of yacc.c  */
-#line 843 "parser.yy"
+#line 844 "parser.yy"
     { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); }
     break;
@@ -5963 +5964 @@
 
 /* Line 1806 of yacc.c  */
-#line 847 "parser.yy"
+#line 848 "parser.yy"
     { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
     break;
@@ -5970 +5971 @@
 
 /* Line 1806 of yacc.c  */
-#line 850 "parser.yy"
+#line 851 "parser.yy"
     { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); }
     break;
@@ -5977 +5978 @@
 
 /* Line 1806 of yacc.c  */
-#line 854 "parser.yy"
+#line 855 "parser.yy"
     { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); }
     break;
@@ -5984 +5985 @@
 
 /* Line 1806 of yacc.c  */
-#line 857 "parser.yy"
+#line 858 "parser.yy"
     { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
     break;
@@ -5991 +5992 @@
 
 /* Line 1806 of yacc.c  */
-#line 861 "parser.yy"
+#line 862 "parser.yy"
     { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); }
     break;
@@ -5998 +5999 @@
 
 /* Line 1806 of yacc.c  */
-#line 863 "parser.yy"
+#line 864 "parser.yy"
     { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); }
     break;
@@ -6005 +6006 @@
 
 /* Line 1806 of yacc.c  */
-#line 865 "parser.yy"
+#line 866 "parser.yy"
     { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
     break;
@@ -6012 +6013 @@
 
 /* Line 1806 of yacc.c  */
-#line 867 "parser.yy"
+#line 868 "parser.yy"
     { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
     break;
@@ -6019 +6020 @@
 
 /* Line 1806 of yacc.c  */
-#line 869 "parser.yy"
+#line 870 "parser.yy"
     { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); }
     break;
@@ -6026 +6027 @@
 
 /* Line 1806 of yacc.c  */
-#line 874 "parser.yy"
+#line 875 "parser.yy"
     { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); }
     break;
@@ -6033 +6034 @@
 
 /* Line 1806 of yacc.c  */
-#line 876 "parser.yy"
+#line 877 "parser.yy"
     { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); }
     break;
@@ -6040 +6041 @@
 
 /* Line 1806 of yacc.c  */
-#line 878 "parser.yy"
+#line 879 "parser.yy"
     { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); }
     break;
@@ -6047 +6048 @@
 
 /* Line 1806 of yacc.c  */
-#line 885 "parser.yy"
+#line 886 "parser.yy"
     { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
     break;
@@ -6054 +6055 @@
 
 /* Line 1806 of yacc.c  */
-#line 887 "parser.yy"
+#line 888 "parser.yy"
     { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
     break;
@@ -6061 +6062 @@
 
 /* Line 1806 of yacc.c  */
-#line 889 "parser.yy"
+#line 890 "parser.yy"
     { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
     break;
@@ -6068 +6069 @@
 
 /* Line 1806 of yacc.c  */
-#line 891 "parser.yy"
+#line 892 "parser.yy"
     { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
     break;
@@ -6075 +6076 @@
 
 /* Line 1806 of yacc.c  */
-#line 896 "parser.yy"
+#line 897 "parser.yy"
     { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
     break;
@@ -6082 +6083 @@
 
 /* Line 1806 of yacc.c  */
-#line 898 "parser.yy"
+#line 899 "parser.yy"
     { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
     break;
@@ -6089 +6090 @@
 
 /* Line 1806 of yacc.c  */
-#line 900 "parser.yy"
+#line 901 "parser.yy"
     { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
     break;
@@ -6096 +6097 @@
 
 /* Line 1806 of yacc.c  */
-#line 902 "parser.yy"
+#line 903 "parser.yy"
     { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
     break;
@@ -6103 +6104 @@
 
 /* Line 1806 of yacc.c  */
-#line 907 "parser.yy"
+#line 908 "parser.yy"
     {
                         (yyval.sn) = new StatementNode( build_finally( (yyvsp[(2) - (2)].sn) ) );
@@ -6112 +6113 @@
 
 /* Line 1806 of yacc.c  */
-#line 920 "parser.yy"
+#line 921 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6122 +6123 @@
 
 /* Line 1806 of yacc.c  */
-#line 925 "parser.yy"
+#line 926 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -6129 +6130 @@
 
 /* Line 1806 of yacc.c  */
-#line 927 "parser.yy"
+#line 928 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6139 +6140 @@
 
 /* Line 1806 of yacc.c  */
-#line 936 "parser.yy"
+#line 937 "parser.yy"
     { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); }
     break;
@@ -6146 +6147 @@
 
 /* Line 1806 of yacc.c  */
-#line 938 "parser.yy"
+#line 939 "parser.yy"
     { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); }
     break;
@@ -6153 +6154 @@
 
 /* Line 1806 of yacc.c  */
-#line 940 "parser.yy"
+#line 941 "parser.yy"
     { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); }
     break;
@@ -6160 +6161 @@
 
 /* Line 1806 of yacc.c  */
-#line 942 "parser.yy"
+#line 943 "parser.yy"
     { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ) ); }
     break;
@@ -6167 +6168 @@
 
 /* Line 1806 of yacc.c  */
-#line 944 "parser.yy"
+#line 945 "parser.yy"
     { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ) ); }
     break;
@@ -6174 +6175 @@
 
 /* Line 1806 of yacc.c  */
-#line 949 "parser.yy"
+#line 950 "parser.yy"
     { (yyval.flag) = false; }
     break;
@@ -6181 +6182 @@
 
 /* Line 1806 of yacc.c  */
-#line 951 "parser.yy"
+#line 952 "parser.yy"
     { (yyval.flag) = true; }
     break;
@@ -6188 +6189 @@
 
 /* Line 1806 of yacc.c  */
-#line 956 "parser.yy"
+#line 957 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -6195 +6196 @@
 
 /* Line 1806 of yacc.c  */
-#line 963 "parser.yy"
+#line 964 "parser.yy"
     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
     break;
@@ -6202 +6203 @@
 
 /* Line 1806 of yacc.c  */
-#line 968 "parser.yy"
+#line 969 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_asmexpr( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); }
     break;
@@ -6209 +6210 @@
 
 /* Line 1806 of yacc.c  */
-#line 970 "parser.yy"
+#line 971 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_asmexpr( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); }
     break;
@@ -6216 +6217 @@
 
 /* Line 1806 of yacc.c  */
-#line 975 "parser.yy"
+#line 976 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -6223 +6224 @@
 
 /* Line 1806 of yacc.c  */
-#line 977 "parser.yy"
+#line 978 "parser.yy"
     { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
     break;
@@ -6230 +6231 @@
 
 /* Line 1806 of yacc.c  */
-#line 979 "parser.yy"
+#line 980 "parser.yy"
     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); }
     break;
@@ -6237 +6238 @@
 
 /* Line 1806 of yacc.c  */
-#line 984 "parser.yy"
+#line 985 "parser.yy"
     {
                         (yyval.label) = new LabelNode(); (yyval.label)->labels.push_back( *(yyvsp[(1) - (1)].tok) );
@@ -6247 +6248 @@
 
 /* Line 1806 of yacc.c  */
-#line 989 "parser.yy"
+#line 990 "parser.yy"
     {
                         (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->labels.push_back( *(yyvsp[(3) - (3)].tok) );
@@ -6257 +6258 @@
 
 /* Line 1806 of yacc.c  */
-#line 999 "parser.yy"
+#line 1000 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -6264 +6265 @@
 
 /* Line 1806 of yacc.c  */
-#line 1006 "parser.yy"
+#line 1007 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -6271 +6272 @@
 
 /* Line 1806 of yacc.c  */
-#line 1011 "parser.yy"
+#line 1012 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -6278 +6279 @@
 
 /* Line 1806 of yacc.c  */
-#line 1018 "parser.yy"
+#line 1019 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     break;
 
   case 244:
-
-/* Line 1806 of yacc.c  */
-#line 1032 "parser.yy"
-    {}
-    break;
-
-  case 245:
 
 /* Line 1806 of yacc.c  */
@@ -6296 +6290 @@
     break;
 
+  case 245:
+
+/* Line 1806 of yacc.c  */
+#line 1034 "parser.yy"
+    {}
+    break;
+
   case 253:
 
 /* Line 1806 of yacc.c  */
-#line 1062 "parser.yy"
+#line 1063 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6309 +6310 @@
 
 /* Line 1806 of yacc.c  */
-#line 1069 "parser.yy"
+#line 1070 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6319 +6320 @@
 
 /* Line 1806 of yacc.c  */
-#line 1074 "parser.yy"
+#line 1075 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
@@ -6329 +6330 @@
 
 /* Line 1806 of yacc.c  */
-#line 1084 "parser.yy"
+#line 1085 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
@@ -6339 +6340 @@
 
 /* Line 1806 of yacc.c  */
-#line 1089 "parser.yy"
+#line 1090 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
@@ -6349 +6350 @@
 
 /* Line 1806 of yacc.c  */
-#line 1094 "parser.yy"
+#line 1095 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
@@ -6359 +6360 @@
 
 /* Line 1806 of yacc.c  */
-#line 1102 "parser.yy"
+#line 1103 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6369 +6370 @@
 
 /* Line 1806 of yacc.c  */
-#line 1107 "parser.yy"
+#line 1108 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6379 +6380 @@
 
 /* Line 1806 of yacc.c  */
-#line 1112 "parser.yy"
+#line 1113 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6389 +6390 @@
 
 /* Line 1806 of yacc.c  */
-#line 1117 "parser.yy"
+#line 1118 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6399 +6400 @@
 
 /* Line 1806 of yacc.c  */
-#line 1122 "parser.yy"
+#line 1123 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
@@ -6409 +6410 @@
 
 /* Line 1806 of yacc.c  */
-#line 1130 "parser.yy"
+#line 1131 "parser.yy"
     {
                         (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
@@ -6418 +6419 @@
 
 /* Line 1806 of yacc.c  */
-#line 1153 "parser.yy"
+#line 1154 "parser.yy"
     {
                         (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
@@ -6427 +6428 @@
 
 /* Line 1806 of yacc.c  */
-#line 1157 "parser.yy"
+#line 1158 "parser.yy"
     {
                         (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
@@ -6436 +6437 @@
 
 /* Line 1806 of yacc.c  */
-#line 1164 "parser.yy"
+#line 1165 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
     break;
@@ -6443 +6444 @@
 
 /* Line 1806 of yacc.c  */
-#line 1168 "parser.yy"
+#line 1169 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
     break;
@@ -6450 +6451 @@
 
 /* Line 1806 of yacc.c  */
-#line 1173 "parser.yy"
+#line 1174 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6460 +6461 @@
 
 /* Line 1806 of yacc.c  */
-#line 1178 "parser.yy"
+#line 1179 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6470 +6471 @@
 
 /* Line 1806 of yacc.c  */
-#line 1183 "parser.yy"
+#line 1184 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
@@ -6480 +6481 @@
 
 /* Line 1806 of yacc.c  */
-#line 1194 "parser.yy"
+#line 1195 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6490 +6491 @@
 
 /* Line 1806 of yacc.c  */
-#line 1199 "parser.yy"
+#line 1200 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6500 +6501 @@
 
 /* Line 1806 of yacc.c  */
-#line 1204 "parser.yy"
+#line 1205 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6510 +6511 @@
 
 /* Line 1806 of yacc.c  */
-#line 1209 "parser.yy"
+#line 1210 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6520 +6521 @@
 
 /* Line 1806 of yacc.c  */
-#line 1214 "parser.yy"
+#line 1215 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6530 +6531 @@
 
 /* Line 1806 of yacc.c  */
-#line 1223 "parser.yy"
+#line 1224 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
@@ -6540 +6541 @@
 
 /* Line 1806 of yacc.c  */
-#line 1228 "parser.yy"
+#line 1229 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
@@ -6550 +6551 @@
 
 /* Line 1806 of yacc.c  */
-#line 1245 "parser.yy"
+#line 1246 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6560 +6561 @@
 
 /* Line 1806 of yacc.c  */
-#line 1250 "parser.yy"
+#line 1251 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6570 +6571 @@
 
 /* Line 1806 of yacc.c  */
-#line 1272 "parser.yy"
+#line 1273 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -6577 +6578 @@
 
 /* Line 1806 of yacc.c  */
-#line 1284 "parser.yy"
+#line 1285 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6584 +6585 @@
 
 /* Line 1806 of yacc.c  */
-#line 1295 "parser.yy"
+#line 1296 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
     break;
@@ -6591 +6592 @@
 
 /* Line 1806 of yacc.c  */
-#line 1297 "parser.yy"
+#line 1298 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
     break;
@@ -6598 +6599 @@
 
 /* Line 1806 of yacc.c  */
-#line 1299 "parser.yy"
+#line 1300 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
     break;
@@ -6605 +6606 @@
 
 /* Line 1806 of yacc.c  */
-#line 1301 "parser.yy"
+#line 1302 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
     break;
@@ -6612 +6613 @@
 
 /* Line 1806 of yacc.c  */
-#line 1303 "parser.yy"
+#line 1304 "parser.yy"
     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
     break;
@@ -6619 +6620 @@
 
 /* Line 1806 of yacc.c  */
-#line 1305 "parser.yy"
+#line 1306 "parser.yy"
     {
                         typedefTable.enterScope();
@@ -6628 +6629 @@
 
 /* Line 1806 of yacc.c  */
-#line 1309 "parser.yy"
+#line 1310 "parser.yy"
     {
                         typedefTable.leaveScope();
@@ -6638 +6639 @@
 
 /* Line 1806 of yacc.c  */
-#line 1318 "parser.yy"
+#line 1319 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6645 +6646 @@
 
 /* Line 1806 of yacc.c  */
-#line 1320 "parser.yy"
+#line 1321 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -6652 +6653 @@
 
 /* Line 1806 of yacc.c  */
-#line 1331 "parser.yy"
+#line 1332 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6659 +6660 @@
 
 /* Line 1806 of yacc.c  */
-#line 1336 "parser.yy"
+#line 1337 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
     break;
@@ -6666 +6667 @@
 
 /* Line 1806 of yacc.c  */
-#line 1338 "parser.yy"
+#line 1339 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
     break;
@@ -6673 +6674 @@
 
 /* Line 1806 of yacc.c  */
-#line 1340 "parser.yy"
+#line 1341 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
     break;
@@ -6680 +6681 @@
 
 /* Line 1806 of yacc.c  */
-#line 1342 "parser.yy"
+#line 1343 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
     break;
@@ -6687 +6688 @@
 
 /* Line 1806 of yacc.c  */
-#line 1345 "parser.yy"
+#line 1346 "parser.yy"
     { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; }
     break;
@@ -6694 +6695 @@
 
 /* Line 1806 of yacc.c  */
-#line 1347 "parser.yy"
+#line 1348 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
     break;
@@ -6701 +6702 @@
 
 /* Line 1806 of yacc.c  */
-#line 1350 "parser.yy"
+#line 1351 "parser.yy"
     { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; }
     break;
@@ -6708 +6709 @@
 
 /* Line 1806 of yacc.c  */
-#line 1352 "parser.yy"
+#line 1353 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
     break;
@@ -6715 +6716 @@
 
 /* Line 1806 of yacc.c  */
-#line 1357 "parser.yy"
+#line 1358 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
     break;
@@ -6722 +6723 @@
 
 /* Line 1806 of yacc.c  */
-#line 1359 "parser.yy"
+#line 1360 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
     break;
@@ -6729 +6730 @@
 
 /* Line 1806 of yacc.c  */
-#line 1361 "parser.yy"
+#line 1362 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
     break;
@@ -6736 +6737 @@
 
 /* Line 1806 of yacc.c  */
-#line 1363 "parser.yy"
+#line 1364 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
     break;
@@ -6743 +6744 @@
 
 /* Line 1806 of yacc.c  */
-#line 1365 "parser.yy"
+#line 1366 "parser.yy"
     { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); }
     break;
@@ -6750 +6751 @@
 
 /* Line 1806 of yacc.c  */
-#line 1367 "parser.yy"
+#line 1368 "parser.yy"
     { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); }
     break;
@@ -6757 +6758 @@
 
 /* Line 1806 of yacc.c  */
-#line 1369 "parser.yy"
+#line 1370 "parser.yy"
     { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
     break;
@@ -6764 +6765 @@
 
 /* Line 1806 of yacc.c  */
-#line 1371 "parser.yy"
+#line 1372 "parser.yy"
     { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
     break;
@@ -6771 +6772 @@
 
 /* Line 1806 of yacc.c  */
-#line 1373 "parser.yy"
+#line 1374 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
     break;
@@ -6778 +6779 @@
 
 /* Line 1806 of yacc.c  */
-#line 1375 "parser.yy"
+#line 1376 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
     break;
@@ -6785 +6786 @@
 
 /* Line 1806 of yacc.c  */
-#line 1377 "parser.yy"
+#line 1378 "parser.yy"
     { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
     break;
@@ -6792 +6793 @@
 
 /* Line 1806 of yacc.c  */
-#line 1379 "parser.yy"
+#line 1380 "parser.yy"
     { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
     break;
@@ -6799 +6800 @@
 
 /* Line 1806 of yacc.c  */
-#line 1381 "parser.yy"
+#line 1382 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
     break;
@@ -6806 +6807 @@
 
 /* Line 1806 of yacc.c  */
-#line 1388 "parser.yy"
+#line 1389 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -6813 +6814 @@
 
 /* Line 1806 of yacc.c  */
-#line 1390 "parser.yy"
+#line 1391 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6820 +6821 @@
 
 /* Line 1806 of yacc.c  */
-#line 1392 "parser.yy"
+#line 1393 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -6827 +6828 @@
 
 /* Line 1806 of yacc.c  */
-#line 1394 "parser.yy"
+#line 1395 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
     break;
@@ -6834 +6835 @@
 
 /* Line 1806 of yacc.c  */
-#line 1400 "parser.yy"
+#line 1401 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -6841 +6842 @@
 
 /* Line 1806 of yacc.c  */
-#line 1407 "parser.yy"
+#line 1408 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -6848 +6849 @@
 
 /* Line 1806 of yacc.c  */
-#line 1409 "parser.yy"
+#line 1410 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6855 +6856 @@
 
 /* Line 1806 of yacc.c  */
-#line 1411 "parser.yy"
+#line 1412 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6862 +6863 @@
 
 /* Line 1806 of yacc.c  */
-#line 1416 "parser.yy"
+#line 1417 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
     break;
@@ -6869 +6870 @@
 
 /* Line 1806 of yacc.c  */
-#line 1418 "parser.yy"
+#line 1419 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
     break;
@@ -6876 +6877 @@
 
 /* Line 1806 of yacc.c  */
-#line 1420 "parser.yy"
+#line 1421 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
     break;
@@ -6883 +6884 @@
 
 /* Line 1806 of yacc.c  */
-#line 1422 "parser.yy"
+#line 1423 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
     break;
@@ -6890 +6891 @@
 
 /* Line 1806 of yacc.c  */
-#line 1428 "parser.yy"
+#line 1429 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -6897 +6898 @@
 
 /* Line 1806 of yacc.c  */
-#line 1430 "parser.yy"
+#line 1431 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6904 +6905 @@
 
 /* Line 1806 of yacc.c  */
-#line 1432 "parser.yy"
+#line 1433 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -6911 +6912 @@
 
 /* Line 1806 of yacc.c  */
-#line 1438 "parser.yy"
+#line 1439 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -6918 +6919 @@
 
 /* Line 1806 of yacc.c  */
-#line 1440 "parser.yy"
+#line 1441 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6925 +6926 @@
 
 /* Line 1806 of yacc.c  */
-#line 1446 "parser.yy"
+#line 1447 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -6932 +6933 @@
 
 /* Line 1806 of yacc.c  */
-#line 1448 "parser.yy"
+#line 1449 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6939 +6940 @@
 
 /* Line 1806 of yacc.c  */
-#line 1450 "parser.yy"
+#line 1451 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -6946 +6947 @@
 
 /* Line 1806 of yacc.c  */
-#line 1455 "parser.yy"
+#line 1456 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
     break;
@@ -6953 +6954 @@
 
 /* Line 1806 of yacc.c  */
-#line 1457 "parser.yy"
+#line 1458 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -6960 +6961 @@
 
 /* Line 1806 of yacc.c  */
-#line 1459 "parser.yy"
+#line 1460 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6967 +6968 @@
 
 /* Line 1806 of yacc.c  */
-#line 1469 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
+#line 1470 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), nullptr, nullptr, (yyvsp[(3) - (4)].decl), true ); }
     break;
 
@@ -6974 +6975 @@
 
 /* Line 1806 of yacc.c  */
-#line 1471 "parser.yy"
+#line 1472 "parser.yy"
     {
                         typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
-                        (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (2)].aggKey), (yyvsp[(2) - (2)].tok), 0, 0, false );
+                        (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (2)].aggKey), (yyvsp[(2) - (2)].tok), nullptr, nullptr, false );
                 }
     break;
@@ -6984 +6985 @@
 
 /* Line 1806 of yacc.c  */
-#line 1476 "parser.yy"
+#line 1477 "parser.yy"
     { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
     break;
@@ -6991 +6992 @@
 
 /* Line 1806 of yacc.c  */
-#line 1478 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
+#line 1479 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), nullptr, (yyvsp[(5) - (6)].decl), true ); }
     break;
 
@@ -6998 +6999 @@
 
 /* Line 1806 of yacc.c  */
-#line 1480 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
+#line 1481 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), nullptr, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
     break;
 
@@ -7005 +7006 @@
 
 /* Line 1806 of yacc.c  */
-#line 1482 "parser.yy"
+#line 1483 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
     break;
@@ -7012 +7013 @@
 
 /* Line 1806 of yacc.c  */
-#line 1487 "parser.yy"
+#line 1488 "parser.yy"
     { (yyval.aggKey) = DeclarationNode::Struct; }
     break;
@@ -7019 +7020 @@
 
 /* Line 1806 of yacc.c  */
-#line 1489 "parser.yy"
+#line 1490 "parser.yy"
     { (yyval.aggKey) = DeclarationNode::Union; }
     break;
@@ -7026 +7027 @@
 
 /* Line 1806 of yacc.c  */
-#line 1494 "parser.yy"
+#line 1495 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -7033 +7034 @@
 
 /* Line 1806 of yacc.c  */
-#line 1496 "parser.yy"
+#line 1497 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
     break;
@@ -7040 +7041 @@
 
 /* Line 1806 of yacc.c  */
-#line 1502 "parser.yy"
+#line 1503 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
     break;
@@ -7047 +7048 @@
 
 /* Line 1806 of yacc.c  */
-#line 1505 "parser.yy"
+#line 1506 "parser.yy"
     {   // mark all fields in list
                         for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
@@ -7058 +7059 @@
 
 /* Line 1806 of yacc.c  */
-#line 1515 "parser.yy"
+#line 1516 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
     break;
@@ -7065 +7066 @@
 
 /* Line 1806 of yacc.c  */
-#line 1517 "parser.yy"
+#line 1518 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
     break;
@@ -7072 +7073 @@
 
 /* Line 1806 of yacc.c  */
-#line 1519 "parser.yy"
+#line 1520 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
     break;
@@ -7079 +7080 @@
 
 /* Line 1806 of yacc.c  */
-#line 1524 "parser.yy"
+#line 1525 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7086 +7087 @@
 
 /* Line 1806 of yacc.c  */
-#line 1526 "parser.yy"
+#line 1527 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
     break;
@@ -7093 +7094 @@
 
 /* Line 1806 of yacc.c  */
-#line 1531 "parser.yy"
+#line 1532 "parser.yy"
     { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
     break;
@@ -7100 +7101 @@
 
 /* Line 1806 of yacc.c  */
-#line 1533 "parser.yy"
+#line 1534 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
     break;
@@ -7107 +7108 @@
 
 /* Line 1806 of yacc.c  */
-#line 1536 "parser.yy"
+#line 1537 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     break;
@@ -7114 +7115 @@
 
 /* Line 1806 of yacc.c  */
-#line 1539 "parser.yy"
+#line 1540 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     break;
@@ -7121 +7122 @@
 
 /* Line 1806 of yacc.c  */
-#line 1545 "parser.yy"
+#line 1546 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -7128 +7129 @@
 
 /* Line 1806 of yacc.c  */
-#line 1547 "parser.yy"
+#line 1548 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
@@ -7135 +7136 @@
 
 /* Line 1806 of yacc.c  */
-#line 1552 "parser.yy"
+#line 1553 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -7142 +7143 @@
 
 /* Line 1806 of yacc.c  */
-#line 1561 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
+#line 1562 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newEnum( nullptr, (yyvsp[(3) - (5)].decl) ); }
     break;
 
@@ -7149 +7150 @@
 
 /* Line 1806 of yacc.c  */
-#line 1563 "parser.yy"
+#line 1564 "parser.yy"
     {
                         typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
@@ -7159 +7160 @@
 
 /* Line 1806 of yacc.c  */
-#line 1568 "parser.yy"
+#line 1569 "parser.yy"
     { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
     break;
@@ -7166 +7167 @@
 
 /* Line 1806 of yacc.c  */
-#line 1570 "parser.yy"
+#line 1571 "parser.yy"
     { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
     break;
@@ -7173 +7174 @@
 
 /* Line 1806 of yacc.c  */
-#line 1575 "parser.yy"
+#line 1576 "parser.yy"
     { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
     break;
@@ -7180 +7181 @@
 
 /* Line 1806 of yacc.c  */
-#line 1577 "parser.yy"
+#line 1578 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
     break;
@@ -7187 +7188 @@
 
 /* Line 1806 of yacc.c  */
-#line 1582 "parser.yy"
+#line 1583 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -7194 +7195 @@
 
 /* Line 1806 of yacc.c  */
-#line 1584 "parser.yy"
+#line 1585 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -7201 +7202 @@
 
 /* Line 1806 of yacc.c  */
-#line 1591 "parser.yy"
+#line 1592 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -7208 +7209 @@
 
 /* Line 1806 of yacc.c  */
-#line 1599 "parser.yy"
+#line 1600 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7215 +7216 @@
 
 /* Line 1806 of yacc.c  */
-#line 1601 "parser.yy"
+#line 1602 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7222 +7223 @@
 
 /* Line 1806 of yacc.c  */
-#line 1603 "parser.yy"
+#line 1604 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7229 +7230 @@
 
 /* Line 1806 of yacc.c  */
-#line 1611 "parser.yy"
+#line 1612 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7236 +7237 @@
 
 /* Line 1806 of yacc.c  */
-#line 1613 "parser.yy"
+#line 1614 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7243 +7244 @@
 
 /* Line 1806 of yacc.c  */
-#line 1615 "parser.yy"