Index: src/Common/Assert.cc =================================================================== --- src/Common/Assert.cc (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) +++ src/Common/Assert.cc (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -0,0 +1,45 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Assert.cc -- +// +// Author : Peter A. Buhr +// Created On : Thu Aug 18 13:26:59 2016 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu Aug 18 23:40:29 2016 +// Update Count : 8 +// + +#include +#include +#include +#include + +extern const char * __progname; // global name of running executable (argv[0]) + +#define CFA_ASSERT_FMT "*CFA assertion error* from program \"%s\" in \"%s\" at line %d in file \"%s\"" + +// called by macro assert in assert.h +void __assert_fail( const char *assertion, const char *file, unsigned int line, const char *function ) { + fprintf( stderr, CFA_ASSERT_FMT ".\n", __progname, function, line, file ); + exit( EXIT_FAILURE ); +} + +// called by macro assertf +void __assert_fail_f( const char *assertion, const char *file, unsigned int line, const char *function, const char *fmt, ... ) { + fprintf( stderr, CFA_ASSERT_FMT ": ", __progname, function, line, file ); + va_list args; + va_start( args, fmt ); + vfprintf( stderr, fmt, args ); + exit( EXIT_FAILURE ); +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // + Index: src/Common/CompilerError.h =================================================================== --- src/Common/CompilerError.h (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Common/CompilerError.h (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue May 19 07:20:37 2015 -// Update Count : 2 +// Last Modified On : Thu Aug 18 23:41:30 2016 +// Update Count : 3 // @@ -18,5 +18,4 @@ #include -//#include "../config.h" class CompilerError : public std::exception { Index: src/Common/module.mk =================================================================== --- src/Common/module.mk (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Common/module.mk (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -11,8 +11,9 @@ ## Created On : Mon Jun 1 17:49:17 2015 ## Last Modified By : Peter A. Buhr -## Last Modified On : Mon Jun 1 17:51:23 2015 -## Update Count : 1 +## Last Modified On : Thu Aug 18 13:29:04 2016 +## Update Count : 2 ############################################################################### SRC += Common/SemanticError.cc \ - Common/UniqueName.cc + Common/UniqueName.cc \ + Common/Assert.cc Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Common/utility.h (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -49,4 +49,12 @@ } +template< typename T, typename U > +static inline T * maybeMoveBuild( const U *orig ) { + T* ret = maybeBuild(orig); + delete orig; + return ret; +} + + template< typename Input_iterator > void printEnums( Input_iterator begin, Input_iterator end, const char * const *name_array, std::ostream &os ) { Index: src/Makefile.am =================================================================== --- src/Makefile.am (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Makefile.am (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -11,6 +11,6 @@ ## Created On : Sun May 31 08:51:46 2015 ## Last Modified By : Peter A. Buhr -## Last Modified On : Fri Jul 8 12:22:25 2016 -## Update Count : 60 +## Last Modified On : Thu Aug 18 17:47:06 2016 +## Update Count : 70 ############################################################################### @@ -42,9 +42,6 @@ cfa_cpplib_PROGRAMS = driver/cfa-cpp driver_cfa_cpp_SOURCES = ${SRC} -driver_cfa_cpp_LDADD = ${LEXLIB} # yywrap -# need files Common/utility.h -driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL - -AM_CXXFLAGS = -g -std=c++11 +driver_cfa_cpp_LDADD = ${LEXLIB} # yywrap +driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include MAINTAINERCLEANFILES += ${libdir}/${notdir ${cfa_cpplib_PROGRAMS}} Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Makefile.in (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -105,4 +105,5 @@ Common/driver_cfa_cpp-SemanticError.$(OBJEXT) \ Common/driver_cfa_cpp-UniqueName.$(OBJEXT) \ + Common/driver_cfa_cpp-Assert.$(OBJEXT) \ ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT) \ ControlStruct/driver_cfa_cpp-LabelFixer.$(OBJEXT) \ @@ -137,5 +138,4 @@ Parser/driver_cfa_cpp-LinkageSpec.$(OBJEXT) \ Parser/driver_cfa_cpp-parseutility.$(OBJEXT) \ - Parser/driver_cfa_cpp-Parser.$(OBJEXT) \ ResolvExpr/driver_cfa_cpp-AlternativeFinder.$(OBJEXT) \ ResolvExpr/driver_cfa_cpp-Alternative.$(OBJEXT) \ @@ -370,5 +370,5 @@ CodeGen/CodeGenerator.cc CodeGen/GenType.cc \ CodeGen/FixNames.cc CodeGen/OperatorTable.cc \ - Common/SemanticError.cc Common/UniqueName.cc \ + Common/SemanticError.cc Common/UniqueName.cc Common/Assert.cc \ ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \ ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \ @@ -385,5 +385,5 @@ Parser/ExpressionNode.cc Parser/StatementNode.cc \ Parser/InitializerNode.cc Parser/TypeData.cc \ - Parser/LinkageSpec.cc Parser/parseutility.cc Parser/Parser.cc \ + Parser/LinkageSpec.cc Parser/parseutility.cc \ ResolvExpr/AlternativeFinder.cc ResolvExpr/Alternative.cc \ ResolvExpr/Unify.cc ResolvExpr/PtrsAssignable.cc \ @@ -426,8 +426,6 @@ cfa_cpplibdir = ${libdir} driver_cfa_cpp_SOURCES = ${SRC} -driver_cfa_cpp_LDADD = ${LEXLIB} # yywrap -# need files Common/utility.h -driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -AM_CXXFLAGS = -g -std=c++11 +driver_cfa_cpp_LDADD = ${LEXLIB} # yywrap +driver_cfa_cpp_CXXFLAGS = -Wno-deprecated -Wall -DDEBUG_ALL -I${abs_top_srcdir}/src/include all: $(BUILT_SOURCES) $(MAKE) $(AM_MAKEFLAGS) all-am @@ -528,4 +526,6 @@ Common/$(DEPDIR)/$(am__dirstamp) Common/driver_cfa_cpp-UniqueName.$(OBJEXT): Common/$(am__dirstamp) \ + Common/$(DEPDIR)/$(am__dirstamp) +Common/driver_cfa_cpp-Assert.$(OBJEXT): Common/$(am__dirstamp) \ Common/$(DEPDIR)/$(am__dirstamp) ControlStruct/$(am__dirstamp): @@ -632,6 +632,4 @@ Parser/$(DEPDIR)/$(am__dirstamp) Parser/driver_cfa_cpp-parseutility.$(OBJEXT): Parser/$(am__dirstamp) \ - Parser/$(DEPDIR)/$(am__dirstamp) -Parser/driver_cfa_cpp-Parser.$(OBJEXT): Parser/$(am__dirstamp) \ Parser/$(DEPDIR)/$(am__dirstamp) ResolvExpr/$(am__dirstamp): @@ -817,4 +815,5 @@ -rm -f CodeGen/driver_cfa_cpp-Generate.$(OBJEXT) -rm -f CodeGen/driver_cfa_cpp-OperatorTable.$(OBJEXT) + -rm -f Common/driver_cfa_cpp-Assert.$(OBJEXT) -rm -f Common/driver_cfa_cpp-SemanticError.$(OBJEXT) -rm -f Common/driver_cfa_cpp-UniqueName.$(OBJEXT) @@ -845,5 +844,4 @@ -rm -f Parser/driver_cfa_cpp-LinkageSpec.$(OBJEXT) -rm -f Parser/driver_cfa_cpp-ParseNode.$(OBJEXT) - -rm -f Parser/driver_cfa_cpp-Parser.$(OBJEXT) -rm -f Parser/driver_cfa_cpp-StatementNode.$(OBJEXT) -rm -f Parser/driver_cfa_cpp-TypeData.$(OBJEXT) @@ -927,4 +925,5 @@ @AMDEP_TRUE@@am__include@ @am__quote@CodeGen/$(DEPDIR)/driver_cfa_cpp-Generate.Po@am__quote@ @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-SemanticError.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/driver_cfa_cpp-UniqueName.Po@am__quote@ @@ -955,5 +954,4 @@ @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/driver_cfa_cpp-LinkageSpec.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/driver_cfa_cpp-ParseNode.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/driver_cfa_cpp-Parser.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/driver_cfa_cpp-StatementNode.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@Parser/$(DEPDIR)/driver_cfa_cpp-TypeData.Po@am__quote@ @@ -1169,4 +1167,18 @@ @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-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 +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-Assert.Tpo Common/$(DEPDIR)/driver_cfa_cpp-Assert.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='Common/Assert.cc' object='Common/driver_cfa_cpp-Assert.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-Assert.o `test -f 'Common/Assert.cc' || echo '$(srcdir)/'`Common/Assert.cc + +Common/driver_cfa_cpp-Assert.obj: 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.obj -MD -MP -MF Common/$(DEPDIR)/driver_cfa_cpp-Assert.Tpo -c -o Common/driver_cfa_cpp-Assert.obj `if test -f 'Common/Assert.cc'; then $(CYGPATH_W) 'Common/Assert.cc'; else $(CYGPATH_W) '$(srcdir)/Common/Assert.cc'; fi` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) Common/$(DEPDIR)/driver_cfa_cpp-Assert.Tpo Common/$(DEPDIR)/driver_cfa_cpp-Assert.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='Common/Assert.cc' object='Common/driver_cfa_cpp-Assert.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-Assert.obj `if test -f 'Common/Assert.cc'; then $(CYGPATH_W) 'Common/Assert.cc'; else $(CYGPATH_W) '$(srcdir)/Common/Assert.cc'; fi` + ControlStruct/driver_cfa_cpp-LabelGenerator.o: ControlStruct/LabelGenerator.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-LabelGenerator.o -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelGenerator.Tpo -c -o ControlStruct/driver_cfa_cpp-LabelGenerator.o `test -f 'ControlStruct/LabelGenerator.cc' || echo '$(srcdir)/'`ControlStruct/LabelGenerator.cc @@ -1616,18 +1628,4 @@ @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 Parser/driver_cfa_cpp-parseutility.obj `if test -f 'Parser/parseutility.cc'; then $(CYGPATH_W) 'Parser/parseutility.cc'; else $(CYGPATH_W) '$(srcdir)/Parser/parseutility.cc'; fi` - -Parser/driver_cfa_cpp-Parser.o: Parser/Parser.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Parser/driver_cfa_cpp-Parser.o -MD -MP -MF Parser/$(DEPDIR)/driver_cfa_cpp-Parser.Tpo -c -o Parser/driver_cfa_cpp-Parser.o `test -f 'Parser/Parser.cc' || echo '$(srcdir)/'`Parser/Parser.cc -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) Parser/$(DEPDIR)/driver_cfa_cpp-Parser.Tpo Parser/$(DEPDIR)/driver_cfa_cpp-Parser.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='Parser/Parser.cc' object='Parser/driver_cfa_cpp-Parser.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 Parser/driver_cfa_cpp-Parser.o `test -f 'Parser/Parser.cc' || echo '$(srcdir)/'`Parser/Parser.cc - -Parser/driver_cfa_cpp-Parser.obj: Parser/Parser.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Parser/driver_cfa_cpp-Parser.obj -MD -MP -MF Parser/$(DEPDIR)/driver_cfa_cpp-Parser.Tpo -c -o Parser/driver_cfa_cpp-Parser.obj `if test -f 'Parser/Parser.cc'; then $(CYGPATH_W) 'Parser/Parser.cc'; else $(CYGPATH_W) '$(srcdir)/Parser/Parser.cc'; fi` -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) Parser/$(DEPDIR)/driver_cfa_cpp-Parser.Tpo Parser/$(DEPDIR)/driver_cfa_cpp-Parser.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='Parser/Parser.cc' object='Parser/driver_cfa_cpp-Parser.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 Parser/driver_cfa_cpp-Parser.obj `if test -f 'Parser/Parser.cc'; then $(CYGPATH_W) 'Parser/Parser.cc'; else $(CYGPATH_W) '$(srcdir)/Parser/Parser.cc'; fi` ResolvExpr/driver_cfa_cpp-AlternativeFinder.o: ResolvExpr/AlternativeFinder.cc Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Parser/DeclarationNode.cc (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -10,6 +10,6 @@ // Created On : Sat May 16 12:34:05 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Aug 15 14:30:25 2016 -// Update Count : 172 +// Last Modified On : Thu Aug 18 23:48:23 2016 +// Update Count : 182 // @@ -25,5 +25,4 @@ #include "SynTree/Expression.h" -#include "Parser.h" #include "TypedefTable.h" extern TypedefTable typedefTable; @@ -42,5 +41,5 @@ UniqueName DeclarationNode::anonymous( "__anonymous" ); -extern LinkageSpec::Type linkage; // defined in parser.yy +extern LinkageSpec::Spec linkage; // defined in parser.yy DeclarationNode *DeclarationNode::clone() const { @@ -48,15 +47,26 @@ newnode->type = maybeClone( type ); newnode->name = name; - newnode->storageClasses = storageClasses; -//PAB newnode->bitfieldWidth = maybeClone( bitfieldWidth ); + newnode->storageClass = storageClass; + newnode->isInline = isInline; + newnode->isNoreturn = isNoreturn; newnode->bitfieldWidth = bitfieldWidth; newnode->hasEllipsis = hasEllipsis; newnode->initializer = initializer; - newnode->next = maybeClone( next ); + newnode->set_next( maybeClone( get_next() ) ); newnode->linkage = linkage; return newnode; } // DeclarationNode::clone -DeclarationNode::DeclarationNode() : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage ) { +DeclarationNode::DeclarationNode() + : type( 0 ) + , storageClass( NoStorageClass ) + , isInline( false ) + , isNoreturn( false ) + , bitfieldWidth( 0 ) + , initializer( 0 ) + , hasEllipsis( false ) + , linkage( ::linkage ) + , extension( false ) + , error() { } @@ -83,5 +93,7 @@ } // if - printEnums( storageClasses.begin(), storageClasses.end(), DeclarationNode::storageName, os ); + if(storageClass != NoStorageClass) os << DeclarationNode::storageName[storageClass] << ' '; + if(isInline) os << DeclarationNode::storageName[Inline] << ' '; + if(isNoreturn) os << DeclarationNode::storageName[Noreturn] << ' '; if ( type ) { type->print( os, indent ); @@ -144,5 +156,9 @@ DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) { DeclarationNode *newnode = new DeclarationNode; - newnode->storageClasses.push_back( sc ); + switch (sc) { + case Inline: newnode->isInline = true; break; + case Noreturn: newnode->isNoreturn = true; break; + default: newnode->storageClass = sc; break; + } return newnode; } // DeclarationNode::newStorageClass @@ -284,5 +300,5 @@ newnode->type->array->dimension = size; newnode->type->array->isStatic = isStatic; - if ( newnode->type->array->dimension == 0 || dynamic_cast( newnode->type->array->dimension->build() ) ) { + if ( newnode->type->array->dimension == 0 || newnode->type->array->dimension->isExpressionType() ) { newnode->type->array->isVarLen = false; } else { @@ -360,5 +376,5 @@ DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) { if ( q ) { - storageClasses.splice( storageClasses.end(), q->storageClasses ); + copyStorageClasses(q); if ( q->type ) { if ( ! type ) { @@ -387,5 +403,13 @@ DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) { - storageClasses = q->storageClasses; + isInline = isInline || q->isInline; + isNoreturn = isNoreturn || q->isNoreturn; + if(storageClass == NoStorageClass) { + storageClass = q->storageClass; + } + else if (q->storageClass != NoStorageClass) { + q->error = "invalid combination of storage classes in declaration of "; + } + if(error.empty()) error = q->error; return this; } @@ -447,5 +471,5 @@ DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) { if ( o ) { - storageClasses.splice( storageClasses.end(), o->storageClasses ); + copyStorageClasses( o ); if ( o->type ) { if ( ! type ) { @@ -694,5 +718,5 @@ } // if newnode->type->forall = maybeClone( type->forall ); - newnode->storageClasses = storageClasses; + newnode->copyStorageClasses( this ); newnode->name = assign_strptr( newName ); return newnode; @@ -701,5 +725,5 @@ DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) { if ( o ) { - o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() ); + o->copyStorageClasses( this ); if ( type ) { TypeData *srcType = type; @@ -734,5 +758,5 @@ DeclarationNode *newnode = new DeclarationNode; newnode->type = maybeClone( type ); - newnode->storageClasses = storageClasses; + newnode->copyStorageClasses( this ); newnode->name = assign_strptr( newName ); return newnode; @@ -741,5 +765,5 @@ DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) { if ( o ) { - o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() ); + o->copyStorageClasses( this ); if ( type ) { TypeData *newType = type->clone(); @@ -752,12 +776,6 @@ } // if } // if + delete o; return o; -} - -DeclarationNode *DeclarationNode::appendList( DeclarationNode *node ) { - if ( node != 0 ) { - set_last( node ); - } // if - return this; } @@ -776,5 +794,5 @@ void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList ) { SemanticError errors; - std::back_insert_iterator< std::list< Declaration *> > out( outputList ); + std::back_insert_iterator< std::list< Declaration * > > out( outputList ); const DeclarationNode *cur = firstNode; while ( cur ) { @@ -794,5 +812,5 @@ errors.append( e ); } // try - cur = dynamic_cast( cur->get_next() ); + cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); } // while if ( ! errors.isEmpty() ) { @@ -801,7 +819,7 @@ } -void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList ) { +void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList ) { SemanticError errors; - std::back_insert_iterator< std::list< DeclarationWithType *> > out( outputList ); + std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList ); const DeclarationNode *cur = firstNode; while ( cur ) { @@ -817,11 +835,11 @@ Declaration *decl = cur->build(); if ( decl ) { - if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType *>( decl ) ) { + if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( decl ) ) { *out++ = dwt; - } else if ( StructDecl *agg = dynamic_cast< StructDecl *>( decl ) ) { + } 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 ); delete agg; - } else if ( UnionDecl *agg = dynamic_cast< UnionDecl *>( decl ) ) { + } 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 ); @@ -831,5 +849,5 @@ errors.append( e ); } // try - cur = dynamic_cast< DeclarationNode *>( cur->get_next() ); + cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); } // while if ( ! errors.isEmpty() ) { @@ -838,7 +856,7 @@ } -void buildTypeList( const DeclarationNode *firstNode, std::list< Type *> &outputList ) { +void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList ) { SemanticError errors; - std::back_insert_iterator< std::list< Type *> > out( outputList ); + std::back_insert_iterator< std::list< Type * > > out( outputList ); const DeclarationNode *cur = firstNode; while ( cur ) { @@ -848,5 +866,5 @@ errors.append( e ); } // try - cur = dynamic_cast< DeclarationNode *>( cur->get_next() ); + cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); } // while if ( ! errors.isEmpty() ) { @@ -856,9 +874,10 @@ Declaration *DeclarationNode::build() const { + if( !error.empty() ) throw SemanticError( error, this ); if ( type ) { - return type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildFuncSpecifier( Inline ), buildFuncSpecifier( Noreturn ), linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension ); - } // if - if ( ! buildFuncSpecifier( Inline ) && ! buildFuncSpecifier( Noreturn ) ) { - return (new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension ); + return type->buildDecl( name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension ); + } // 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 in declaration of ", this ); @@ -899,23 +918,23 @@ } -DeclarationNode::StorageClass DeclarationNode::buildStorageClass() const { - DeclarationNode::StorageClass ret = DeclarationNode::NoStorageClass; - for ( std::list< DeclarationNode::StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) { - if ( *i == DeclarationNode::Inline || *i == DeclarationNode::Noreturn ) continue; // ignore function specifiers - if ( ret != DeclarationNode::NoStorageClass ) { // already have a valid storage class ? - throw SemanticError( "invalid combination of storage classes in declaration of ", this ); - } // if - ret = *i; - } // for - return ret; -} - -bool DeclarationNode::buildFuncSpecifier( DeclarationNode::StorageClass key ) const { - std::list< DeclarationNode::StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), key ); - if ( first == storageClasses.end() ) return false; // not found - first = std::find( ++first, storageClasses.end(), key ); // found - if ( first == storageClasses.end() ) return true; // not found again - throw SemanticError( "duplicate function specifier in declaration of ", this ); -} +// DeclarationNode::StorageClass DeclarationNode::buildStorageClass() const { +// DeclarationNode::StorageClass ret = DeclarationNode::NoStorageClass; +// for ( std::list< DeclarationNode::StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) { +// if ( *i == DeclarationNode::Inline || *i == DeclarationNode::Noreturn ) continue; // ignore function specifiers +// if ( ret != DeclarationNode::NoStorageClass ) { // already have a valid storage class ? +// throw SemanticError( "invalid combination of storage classes in declaration of ", this ); +// } // if +// ret = *i; +// } // for +// return ret; +// } + +// bool DeclarationNode::buildFuncSpecifier( DeclarationNode::StorageClass key ) const { +// std::list< DeclarationNode::StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), key ); +// if ( first == storageClasses.end() ) return false; // not found +// first = std::find( ++first, storageClasses.end(), key ); // found +// if ( first == storageClasses.end() ) return true; // not found again +// throw SemanticError( "duplicate function specifier in declaration of ", this ); +// } // Local Variables: // Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Parser/ExpressionNode.cc (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:17:07 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Aug 15 14:30:42 2016 -// Update Count : 490 +// Last Modified On : Tue Aug 16 00:09:20 2016 +// Update Count : 495 // @@ -32,5 +32,5 @@ using namespace std; -ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ), extension( other.extension ) {} +ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.get_name() ), extension( other.extension ) {} //############################################################################## @@ -57,5 +57,5 @@ static inline bool checkX( char c ) { return c == 'x' || c == 'X'; } -Expression *build_constantInteger( std::string & str ) { +Expression *build_constantInteger( const std::string & str ) { static const BasicType::Kind kind[2][3] = { { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt }, @@ -123,5 +123,5 @@ } // build_constantInteger -Expression *build_constantFloat( std::string & str ) { +Expression *build_constantFloat( const std::string & str ) { static const BasicType::Kind kind[2][3] = { { BasicType::Float, BasicType::Double, BasicType::LongDouble }, @@ -153,9 +153,9 @@ } // build_constantFloat -Expression *build_constantChar( std::string & str ) { +Expression *build_constantChar( const std::string & str ) { return new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ) ); } // build_constantChar -ConstantExpr *build_constantStr( std::string & str ) { +ConstantExpr *build_constantStr( const std::string & str ) { // string should probably be a primitive type ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ), @@ -166,11 +166,9 @@ } // build_constantStr -//############################################################################## - NameExpr * build_varref( const string *name, bool labelp ) { - return new NameExpr( *name, nullptr ); -} - -//############################################################################## + NameExpr *expr = new NameExpr( *name, nullptr ); + delete name; + return expr; +} static const char *OperName[] = { @@ -184,18 +182,16 @@ }; -//############################################################################## - Expression *build_cast( DeclarationNode *decl_node, ExpressionNode *expr_node ) { Type *targetType = decl_node->buildType(); if ( dynamic_cast< VoidType * >( targetType ) ) { delete targetType; - return new CastExpr( maybeBuild(expr_node) ); + return new CastExpr( maybeMoveBuild< Expression >(expr_node) ); } else { - return new CastExpr( maybeBuild(expr_node), targetType ); + return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType ); } // if } Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member ) { - UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeBuild(expr_node) ); + UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeMoveBuild< Expression >(expr_node) ); delete member; return ret; @@ -204,5 +200,5 @@ Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member ) { UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) ); - deref->get_args().push_back( maybeBuild(expr_node) ); + deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) ); UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref ); delete member; @@ -211,14 +207,16 @@ Expression *build_addressOf( ExpressionNode *expr_node ) { - return new AddressExpr( maybeBuild(expr_node) ); + return new AddressExpr( maybeMoveBuild< Expression >(expr_node) ); } Expression *build_sizeOfexpr( ExpressionNode *expr_node ) { - return new SizeofExpr( maybeBuild(expr_node) ); + return new SizeofExpr( maybeMoveBuild< Expression >(expr_node) ); } Expression *build_sizeOftype( DeclarationNode *decl_node ) { - return new SizeofExpr( decl_node->buildType() ); + Expression* ret = new SizeofExpr( decl_node->buildType() ); + delete decl_node; + return ret; } Expression *build_alignOfexpr( ExpressionNode *expr_node ) { - return new AlignofExpr( maybeBuild(expr_node) ); + return new AlignofExpr( maybeMoveBuild< Expression >(expr_node) ); } Expression *build_alignOftype( DeclarationNode *decl_node ) { @@ -226,44 +224,47 @@ } Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member ) { - return new UntypedOffsetofExpr( decl_node->buildType(), member->get_name() ); + Expression* ret = new UntypedOffsetofExpr( decl_node->buildType(), member->get_name() ); + delete decl_node; + delete member; + return ret; } Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind ) { - return new LogicalExpr( notZeroExpr( maybeBuild(expr_node1) ), notZeroExpr( maybeBuild(expr_node2) ), kind ); + return new LogicalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), notZeroExpr( maybeMoveBuild< Expression >(expr_node2) ), kind ); } Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node ) { - std::list args; - args.push_back( maybeBuild(expr_node) ); + std::list< Expression * > args; + args.push_back( maybeMoveBuild< Expression >(expr_node) ); return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); } Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ) { - std::list args; - args.push_back( new AddressExpr( maybeBuild(expr_node) ) ); + std::list< Expression * > args; + args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node) ) ); return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); } Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) { - std::list args; - args.push_back( maybeBuild(expr_node1) ); - args.push_back( maybeBuild(expr_node2) ); + std::list< Expression * > args; + args.push_back( maybeMoveBuild< Expression >(expr_node1) ); + args.push_back( maybeMoveBuild< Expression >(expr_node2) ); return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); } Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) { - std::list args; - args.push_back( new AddressExpr( maybeBuild(expr_node1) ) ); - args.push_back( maybeBuild(expr_node2) ); + std::list< Expression * > args; + args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node1) ) ); + args.push_back( maybeMoveBuild< Expression >(expr_node2) ); return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args ); } Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ) { - return new ConditionalExpr( notZeroExpr( maybeBuild(expr_node1) ), maybeBuild(expr_node2), maybeBuild(expr_node3) ); + return new ConditionalExpr( notZeroExpr( maybeMoveBuild< Expression >(expr_node1) ), maybeMoveBuild< Expression >(expr_node2), maybeMoveBuild< Expression >(expr_node3) ); } Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) { - return new CommaExpr( maybeBuild(expr_node1), maybeBuild(expr_node2) ); + return new CommaExpr( maybeMoveBuild< Expression >(expr_node1), maybeMoveBuild< Expression >(expr_node2) ); } Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node ) { - return new AttrExpr( var, maybeBuild(expr_node) ); + return new AttrExpr( var, maybeMoveBuild< Expression >(expr_node) ); } Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node ) { @@ -273,58 +274,40 @@ Expression *build_tuple( ExpressionNode * expr_node ) { TupleExpr *ret = new TupleExpr(); - buildList( expr_node, ret->get_exprs() ); + buildMoveList( expr_node, ret->get_exprs() ); return ret; } Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node ) { - std::list args; - - buildList( expr_node, args ); - return new UntypedExpr( maybeBuild(function), args, nullptr ); + std::list< Expression * > args; + buildMoveList( expr_node, args ); + return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr ); } Expression *build_range( ExpressionNode * low, ExpressionNode *high ) { - Expression *low_cexpr = maybeBuild( low ); - Expression *high_cexpr = maybeBuild( high ); - return new RangeExpr( low_cexpr, high_cexpr ); -} - -//############################################################################## + return new RangeExpr( maybeMoveBuild< Expression >( low ), maybeMoveBuild< Expression >( high ) ); +} Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand ) { - return new AsmExpr( maybeBuild< Expression >( inout ), constraint, maybeBuild(operand) ); -} - -//############################################################################## - -//void LabelNode::print( std::ostream &os, int indent ) const {} - -//void LabelNode::printOneLine( std::ostream &os, int indent ) const {} - -//############################################################################## + return new AsmExpr( maybeMoveBuild< Expression >( inout ), constraint, maybeMoveBuild< Expression >(operand) ); +} Expression *build_valexpr( StatementNode *s ) { - return new UntypedValofExpr( maybeBuild(s), nullptr ); -} - -//############################################################################## - + return new UntypedValofExpr( maybeMoveBuild< Statement >(s), nullptr ); +} Expression *build_typevalue( DeclarationNode *decl ) { return new TypeExpr( decl->buildType() ); } -//############################################################################## - Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids ) { - Declaration * newDecl = maybeBuild(decl_node); // compound literal type + Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type - return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeBuild(kids) ); + return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeMoveBuild< Initializer >(kids) ); // these types do not have associated type information } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl ) ) { - return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeBuild(kids) ); + return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeMoveBuild< Initializer >(kids) ); } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl ) ) { - return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeBuild(kids) ); + return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeMoveBuild< Initializer >(kids) ); } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl ) ) { - return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeBuild(kids) ); + return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeMoveBuild< Initializer >(kids) ); } else { assert( false ); Index: src/Parser/InitializerNode.cc =================================================================== --- src/Parser/InitializerNode.cc (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Parser/InitializerNode.cc (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:20:24 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Aug 13 18:55:11 2016 -// Update Count : 18 +// Last Modified On : Mon Aug 15 18:27:02 2016 +// Update Count : 20 // @@ -25,5 +25,5 @@ : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) { if ( aggrp ) - kids = dynamic_cast< InitializerNode *>( get_next() ); + kids = dynamic_cast< InitializerNode * >( get_next() ); if ( kids != 0 ) @@ -37,5 +37,5 @@ if ( aggrp ) - kids = dynamic_cast< InitializerNode *>( get_next() ); + kids = dynamic_cast< InitializerNode * >( get_next() ); if ( kids != 0 ) @@ -82,22 +82,22 @@ //assert( next_init() != 0 ); - std::list< Initializer *> initlist; - buildList( next_init(), initlist ); + std::list< Initializer * > initlist; + buildList< Initializer, InitializerNode >( next_init(), initlist ); - std::list< Expression *> designlist; + std::list< Expression * > designlist; if ( designator != 0 ) { - buildList( designator, designlist ); + buildList< Expression, ExpressionNode >( designator, designlist ); } // if return new ListInit( initlist, designlist, maybeConstructed ); } else { - std::list< Expression *> designators; + std::list< Expression * > designators; if ( designator != 0 ) - buildList( designator, designators ); + buildList< Expression, ExpressionNode >( designator, designators ); if ( get_expression() != 0) - return new SingleInit( maybeBuild( get_expression() ), designators, maybeConstructed ); + return new SingleInit( maybeBuild< Expression >( get_expression() ), designators, maybeConstructed ); } // if Index: src/Parser/LinkageSpec.cc =================================================================== --- src/Parser/LinkageSpec.cc (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Parser/LinkageSpec.cc (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -9,7 +9,7 @@ // Author : Rodolfo G. Esteves // Created On : Sat May 16 13:22:09 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Wed Aug 19 15:53:05 2015 -// Update Count : 5 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu Aug 18 23:47:14 2016 +// Update Count : 12 // @@ -20,5 +20,5 @@ #include "Common/SemanticError.h" -LinkageSpec::Type LinkageSpec::fromString( const std::string &stringSpec ) { +LinkageSpec::Spec LinkageSpec::fromString( const std::string &stringSpec ) { if ( stringSpec == "\"Cforall\"" ) { return Cforall; @@ -30,80 +30,46 @@ } -std::string LinkageSpec::toString( LinkageSpec::Type linkage ) { - switch ( linkage ) { - case Intrinsic: - return "intrinsic"; - case Cforall: - return "Cforall"; - case C: - return "C"; - case AutoGen: - return "automatically generated"; - case Compiler: - return "compiler built-in"; - } - assert( false ); - return ""; +std::string LinkageSpec::toString( LinkageSpec::Spec linkage ) { + static const char *linkageKinds[LinkageSpec::NoOfSpecs] = { + "intrinsic", "Cforall", "C", "automatically generated", "compiler built-in", + }; + return linkageKinds[linkage]; } -bool LinkageSpec::isDecoratable( Type t ) { - switch ( t ) { - case Intrinsic: - case Cforall: - case AutoGen: - return true; - case C: - case Compiler: - return false; - } - assert( false ); - return false; +bool LinkageSpec::isDecoratable( Spec t ) { + static bool decoratable[LinkageSpec::NoOfSpecs] = { + // Intrinsic, Cforall, C, AutoGen, Compiler + true, true, false, true, false, + }; + return decoratable[t]; } -bool LinkageSpec::isGeneratable( Type t ) { - switch ( t ) { - case Intrinsic: - case Cforall: - case AutoGen: - case C: - return true; - case Compiler: - return false; - } - assert( false ); - return false; +bool LinkageSpec::isGeneratable( Spec t ) { + static bool generatable[LinkageSpec::NoOfSpecs] = { + // Intrinsic, Cforall, C, AutoGen, Compiler + true, true, true, true, false, + }; + return generatable[t]; } -bool LinkageSpec::isOverloadable( Type t ) { +bool LinkageSpec::isOverloadable( Spec t ) { return isDecoratable( t ); } -bool LinkageSpec::isOverridable( Type t ) { - switch ( t ) { - case Intrinsic: - case AutoGen: - return true; - case Cforall: - case C: - case Compiler: - return false; - } - assert( false ); - return false; +bool LinkageSpec::isOverridable( Spec t ) { + static bool overridable[LinkageSpec::NoOfSpecs] = { + // Intrinsic, Cforall, C, AutoGen, Compiler + true, false, false, true, false, + }; + return overridable[t]; } -bool LinkageSpec::isBuiltin( Type t ) { - switch ( t ) { - case Cforall: - case AutoGen: - case C: - return false; - case Intrinsic: - case Compiler: - return true; - } - assert( false ); - return false; +bool LinkageSpec::isBuiltin( Spec t ) { + static bool builtin[LinkageSpec::NoOfSpecs] = { + // Intrinsic, Cforall, C, AutoGen, Compiler + true, false, false, false, true, + }; + return builtin[t]; } Index: src/Parser/LinkageSpec.h =================================================================== --- src/Parser/LinkageSpec.h (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Parser/LinkageSpec.h (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -9,7 +9,7 @@ // Author : Rodolfo G. Esteves // Created On : Sat May 16 13:24:28 2015 -// Last Modified By : Rob Schluntz -// Last Modified On : Tue Aug 18 14:11:55 2015 -// Update Count : 5 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu Aug 18 23:47:16 2016 +// Update Count : 7 // @@ -20,20 +20,21 @@ struct LinkageSpec { - enum Type { + enum Spec { Intrinsic, // C built-in defined in prelude Cforall, // ordinary C, // not overloadable, not mangled AutoGen, // built by translator (struct assignment) - Compiler // gcc internal + Compiler, // gcc internal + NoOfSpecs }; - static Type fromString( const std::string & ); - static std::string toString( Type ); + static Spec fromString( const std::string & ); + static std::string toString( Spec ); - static bool isDecoratable( Type ); - static bool isGeneratable( Type ); - static bool isOverloadable( Type ); - static bool isOverridable( Type ); - static bool isBuiltin( Type ); + static bool isDecoratable( Spec ); + static bool isGeneratable( Spec ); + static bool isOverloadable( Spec ); + static bool isOverridable( Spec ); + static bool isBuiltin( Spec ); }; Index: src/Parser/ParseNode.cc =================================================================== --- src/Parser/ParseNode.cc (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Parser/ParseNode.cc (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:26:29 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Aug 15 14:49:06 2016 -// Update Count : 99 +// Last Modified On : Wed Aug 17 23:14:16 2016 +// Update Count : 126 // @@ -17,38 +17,5 @@ using namespace std; -// Builder int ParseNode::indent_by = 4; - -ParseNode::ParseNode() : next( 0 ) {}; -ParseNode::ParseNode( const string *name ) : name( *name ), next( 0 ) { delete name; } -ParseNode::ParseNode( const string &name ) : name( name ), next( 0 ) { } - -ParseNode::~ParseNode() { - delete next; -}; - -ParseNode *ParseNode::get_last() { - ParseNode *current = this; - - while ( current->get_next() != 0 ) - current = current->get_next(); - return current; -} - -ParseNode *ParseNode::set_last( ParseNode *next_ ) { - if ( next_ != 0 ) get_last()->next = next_; - return this; -} - -void ParseNode::print( std::ostream &os, int indent ) const {} - - -void ParseNode::printList( std::ostream &os, int indent ) const { - print( os, indent ); - - if ( next ) { - next->printList( os, indent ); - } // if -} // Local Variables: // Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Parser/ParseNode.h (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Aug 15 14:52:12 2016 -// Update Count : 512 +// Last Modified On : Thu Aug 18 23:48:37 2016 +// Update Count : 542 // @@ -22,12 +22,11 @@ #include -#include "Common/utility.h" #include "Parser/LinkageSpec.h" #include "SynTree/Type.h" #include "SynTree/Expression.h" #include "SynTree/Statement.h" -//#include "SynTree/Declaration.h" +#include "SynTree/Label.h" +#include "Common/utility.h" #include "Common/UniqueName.h" -#include "SynTree/Label.h" class StatementNode; @@ -37,31 +36,37 @@ class InitializerNode; -// Builder +//############################################################################## + class ParseNode { public: - ParseNode(); - ParseNode( const std::string * ); - ParseNode( const std::string & ); // for copy constructing subclasses - virtual ~ParseNode(); + 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 *clone() const = 0; ParseNode *get_next() const { return next; } ParseNode *set_next( ParseNode *newlink ) { next = newlink; return this; } - ParseNode *get_last(); - ParseNode *set_last( ParseNode * ); - - virtual ParseNode *clone() const { return 0; }; + ParseNode *get_last() { + ParseNode *current; + for ( current = this; current->get_next() != 0; current = current->get_next() ); + return current; + } + ParseNode *set_last( ParseNode *newlast ) { + if ( newlast != 0 ) 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; - - ParseNode &operator,( ParseNode & ); - protected: + 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; - static int indent_by; - ParseNode *next; -}; +}; // ParseNode //############################################################################## @@ -72,4 +77,5 @@ InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 ); ~InitializerNode(); + virtual InitializerNode *clone() const { assert( false ); return nullptr; } ExpressionNode *get_expression() const { return expr; } @@ -97,5 +103,5 @@ //############################################################################## -class ExpressionNode : public ParseNode { +class ExpressionNode final : public ParseNode { public: ExpressionNode( Expression * expr = nullptr ) : expr( expr ) {} @@ -103,21 +109,25 @@ ExpressionNode( const ExpressionNode &other ); virtual ~ExpressionNode() {} - - virtual ExpressionNode *clone() const { return 0; } + virtual ExpressionNode *clone() const { assert( false ); return nullptr; } bool get_extension() const { return extension; } ExpressionNode *set_extension( bool exten ) { extension = exten; return this; } - virtual void print( std::ostream &os, int indent = 0 ) const {} - virtual void printOneLine( std::ostream &os, int indent = 0 ) const {} - - virtual Expression *build() const { return expr; } + void print( std::ostream &os, int indent = 0 ) const {} + void printOneLine( std::ostream &os, int indent = 0 ) const {} + + template + bool isExpressionType() const { + return nullptr != dynamic_cast(expr.get()); + } + + Expression *build() const { return const_cast(this)->expr.release(); } private: bool extension = false; - Expression *expr; + std::unique_ptr expr; }; template< typename T > -struct maybeBuild_t { +struct maybeBuild_t< Expression, T > { static inline Expression * doit( const T *orig ) { if ( orig ) { @@ -126,5 +136,5 @@ return p; } else { - return 0; + return nullptr; } // if } @@ -146,8 +156,8 @@ }; -Expression *build_constantInteger( std::string &str ); -Expression *build_constantFloat( std::string &str ); -Expression *build_constantChar( std::string &str ); -ConstantExpr *build_constantStr( std::string &str ); +Expression *build_constantInteger( const std::string &str ); +Expression *build_constantFloat( const std::string &str ); +Expression *build_constantChar( const std::string &str ); +ConstantExpr *build_constantStr( const std::string &str ); NameExpr *build_varref( const std::string *name, bool labelp = false ); @@ -228,4 +238,8 @@ static DeclarationNode *newBuiltinType( BuiltinType ); + DeclarationNode(); + ~DeclarationNode(); + DeclarationNode *clone() const; + DeclarationNode *addQualifiers( DeclarationNode *); DeclarationNode *copyStorageClasses( DeclarationNode *); @@ -252,7 +266,8 @@ DeclarationNode *cloneBaseType( DeclarationNode *newdecl ); - DeclarationNode *appendList( DeclarationNode * ); - - DeclarationNode *clone() const; + DeclarationNode *appendList( DeclarationNode *node ) { + return (DeclarationNode *)set_last( node ); + } + void print( std::ostream &os, int indent = 0 ) const; void printList( std::ostream &os, int indent = 0 ) const; @@ -263,5 +278,5 @@ bool get_hasEllipsis() const; const std::string &get_name() const { return name; } - LinkageSpec::Type get_linkage() const { return linkage; } + LinkageSpec::Spec get_linkage() const { return linkage; } DeclarationNode *extractAggregate() const; ExpressionNode *get_enumeratorValue() const { return enumeratorValue; } @@ -269,14 +284,13 @@ bool get_extension() const { return extension; } DeclarationNode *set_extension( bool exten ) { extension = exten; return this; } - - DeclarationNode(); - ~DeclarationNode(); private: - StorageClass buildStorageClass() const; - bool buildFuncSpecifier( StorageClass key ) const; + // StorageClass buildStorageClass() const; + // bool buildFuncSpecifier( StorageClass key ) const; TypeData *type; std::string name; - std::list< StorageClass > storageClasses; + // std::list< StorageClass > storageClasses; + StorageClass storageClass; + bool isInline, isNoreturn; std::list< std::string > attributes; ExpressionNode *bitfieldWidth; @@ -284,6 +298,7 @@ InitializerNode *initializer; bool hasEllipsis; - LinkageSpec::Type linkage; + LinkageSpec::Spec linkage; bool extension = false; + std::string error; static UniqueName anonymous; @@ -294,5 +309,5 @@ //############################################################################## -class StatementNode : public ParseNode { +class StatementNode final : public ParseNode { public: StatementNode() { stmt = nullptr; } @@ -301,9 +316,10 @@ virtual ~StatementNode() {} - virtual StatementNode *clone() const { assert( false ); return nullptr; } - virtual Statement *build() const { return stmt; } + virtual StatementNode *clone() const final { assert( false ); return nullptr; } + Statement *build() const { return const_cast(this)->stmt.release(); } virtual StatementNode *add_label( const std::string * name ) { stmt->get_labels().emplace_back( *name ); + delete name; return this; } @@ -314,5 +330,5 @@ virtual void printList( std::ostream &os, int indent = 0 ) {} private: - Statement *stmt; + std::unique_ptr stmt; }; // StatementNode @@ -351,11 +367,11 @@ void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) { SemanticError errors; - std::back_insert_iterator< std::list< SynTreeType *> > out( outputList ); + std::back_insert_iterator< std::list< SynTreeType * > > out( outputList ); const NodeType *cur = firstNode; while ( cur ) { try { -// SynTreeType *result = dynamic_cast< SynTreeType *>( maybeBuild::type>( cur ) ); - SynTreeType *result = dynamic_cast< SynTreeType *>( maybeBuildbuild())>::element_type>( cur ) ); +// SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) ); + SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) ); if ( result ) { *out++ = result; @@ -365,5 +381,5 @@ errors.append( e ); } // try - cur = dynamic_cast< NodeType *>( cur->get_next() ); + cur = dynamic_cast< NodeType * >( cur->get_next() ); } // while if ( ! errors.isEmpty() ) { @@ -374,6 +390,13 @@ // in DeclarationNode.cc void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList ); -void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList ); +void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList ); void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList ); + +template< typename SynTreeType, typename NodeType > +void buildMoveList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) { + buildList(firstNode, outputList); + delete firstNode; +} + #endif // PARSENODE_H Index: c/Parser/Parser.cc =================================================================== --- src/Parser/Parser.cc (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ (revision ) @@ -1,70 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// Parser.cc -- -// -// Author : Rodolfo G. Esteves -// Created On : Sat May 16 14:54:28 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Mon Mar 21 18:04:47 2016 -// Update Count : 5 -// - -#include "Parser.h" -#include "lex.h" -#include "parser.h" -#include "TypedefTable.h" - -// global variables in cfa.y -extern int yyparse(void); -extern int yydebug; -extern LinkageSpec::Type linkage; -extern TypedefTable typedefTable; -extern DeclarationNode *theTree; - -Parser *Parser::theParser = 0; - -Parser::Parser(): parseTree( 0 ), parseStatus( 1 ) {} - -Parser::~Parser() { - delete parseTree; -} - -Parser &Parser::get_parser() { - if ( theParser == 0 ) { - theParser = new Parser; - } // if - return *theParser; -} - -void Parser::parse( FILE *input ) { - extern FILE *yyin; - yyin = input; - extern int yylineno; - yylineno = 1; - typedefTable.enterScope(); - parseStatus = yyparse(); - parseTree = theTree; -} - -void Parser::set_debug( bool debug ) { - yydebug = debug; -} - -void Parser::set_linkage( LinkageSpec::Type linkage ) { - ::linkage = linkage; -} - -void Parser::freeTree() { - delete parseTree; - parseTree = 0; -} - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: c/Parser/Parser.h =================================================================== --- src/Parser/Parser.h (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ (revision ) @@ -1,56 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// Parser.h -- -// -// Author : Rodolfo G. Esteves -// Created On : Sat May 16 14:56:50 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat May 16 14:58:56 2015 -// Update Count : 2 -// - -#ifndef PARSER_H -#define PARSER_H - -#include - -#include "Parser/ParseNode.h" -#include "LinkageSpec.h" - -class Parser { - public: - static Parser &get_parser(); - - // do the actual parse - void parse( FILE *input ); - - // accessors to return the result of the parse - DeclarationNode *get_parseTree() const { return parseTree; } - int get_parseStatus() const { return parseStatus; } - - // mutators to control parse options - void set_debug( bool debug ); - void set_linkage( LinkageSpec::Type linkage ); - - // free the parse tree without actually destroying the parser - void freeTree(); - - ~Parser(); - private: - Parser(); - static Parser *theParser; - DeclarationNode *parseTree; - int parseStatus; -}; - -#endif // PARSER_H - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/Parser/StatementNode.cc =================================================================== --- src/Parser/StatementNode.cc (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Parser/StatementNode.cc (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -10,6 +10,6 @@ // Created On : Sat May 16 14:59:41 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Aug 15 14:40:05 2016 -// Update Count : 317 +// Last Modified On : Mon Aug 15 20:47:11 2016 +// Update Count : 322 // @@ -32,17 +32,17 @@ if ( agg ) { StatementNode *nextStmt = new StatementNode( new DeclStmt( noLabels, maybeBuild< Declaration >( decl ) ) ); - next = nextStmt; + set_next( nextStmt ); if ( decl->get_next() ) { - next->set_next( new StatementNode( dynamic_cast(decl->get_next()) ) ); + get_next()->set_next( new StatementNode( dynamic_cast< DeclarationNode * >(decl->get_next()) ) ); decl->set_next( 0 ); } // if } else { if ( decl->get_next() ) { - next = new StatementNode( dynamic_cast( decl->get_next() ) ); + set_next(new StatementNode( dynamic_cast< DeclarationNode * >( decl->get_next() ) ) ); decl->set_next( 0 ); } // if agg = decl; } // if - stmt = new DeclStmt( noLabels, maybeBuild(agg) ); + stmt.reset( new DeclStmt( noLabels, maybeBuild< Declaration >(agg) ) ); } else { assert( false ); @@ -54,15 +54,15 @@ // find end of list and maintain previous pointer for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) { - StatementNode *node = dynamic_cast(curr); + StatementNode *node = dynamic_cast< StatementNode * >(curr); assert( node ); - assert( dynamic_cast(node->stmt) ); + assert( dynamic_cast< CaseStmt * >(node->stmt.get()) ); prev = curr; } // for // convert from StatementNode list to Statement list - StatementNode *node = dynamic_cast(prev); - std::list stmts; - buildList( stmt, stmts ); + StatementNode *node = dynamic_cast< StatementNode * >(prev); + std::list< Statement * > stmts; + buildMoveList( stmt, stmts ); // splice any new Statements to end of current Statements - CaseStmt * caseStmt = dynamic_cast(node->stmt); + CaseStmt * caseStmt = dynamic_cast< CaseStmt * >(node->stmt.get()); caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts ); return this; @@ -70,5 +70,5 @@ Statement *build_expr( ExpressionNode *ctl ) { - Expression *e = maybeBuild< Expression >( ctl ); + Expression *e = maybeMoveBuild< Expression >( ctl ); if ( e ) @@ -80,57 +80,57 @@ Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt ) { Statement *thenb, *elseb = 0; - std::list branches; - buildList( then_stmt, branches ); + std::list< Statement * > branches; + buildMoveList< Statement, StatementNode >( then_stmt, branches ); assert( branches.size() == 1 ); thenb = branches.front(); if ( else_stmt ) { - std::list branches; - buildList( else_stmt, branches ); + std::list< Statement * > branches; + buildMoveList< Statement, StatementNode >( else_stmt, branches ); assert( branches.size() == 1 ); elseb = branches.front(); } // if - return new IfStmt( noLabels, notZeroExpr( maybeBuild(ctl) ), thenb, elseb ); + return new IfStmt( noLabels, notZeroExpr( maybeMoveBuild< Expression >(ctl) ), thenb, elseb ); } Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt ) { - std::list branches; - buildList( stmt, branches ); + std::list< Statement * > branches; + buildMoveList< Statement, StatementNode >( stmt, branches ); assert( branches.size() >= 0 ); // size == 0 for switch (...) {}, i.e., no declaration or statements - return new SwitchStmt( noLabels, maybeBuild(ctl), branches ); + return new SwitchStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches ); } Statement *build_case( ExpressionNode *ctl ) { - std::list branches; - return new CaseStmt( noLabels, maybeBuild(ctl), branches ); + std::list< Statement * > branches; + return new CaseStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches ); } Statement *build_default() { - std::list branches; + std::list< Statement * > branches; return new CaseStmt( noLabels, nullptr, branches, true ); } Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind ) { - std::list branches; - buildList( stmt, branches ); - assert( branches.size() == 1 ); - return new WhileStmt( noLabels, notZeroExpr( maybeBuild(ctl) ), branches.front(), kind ); + std::list< Statement * > branches; + buildMoveList< Statement, StatementNode >( stmt, branches ); + assert( branches.size() == 1 ); + return new WhileStmt( noLabels, notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), kind ); } Statement *build_for( ForCtl *forctl, StatementNode *stmt ) { - std::list branches; - buildList( stmt, branches ); - assert( branches.size() == 1 ); - - std::list init; + std::list< Statement * > branches; + buildMoveList< Statement, StatementNode >( stmt, branches ); + assert( branches.size() == 1 ); + + std::list< Statement * > init; if ( forctl->init != 0 ) { - buildList( forctl->init, init ); + buildMoveList( forctl->init, init ); } // if Expression *cond = 0; if ( forctl->condition != 0 ) - cond = notZeroExpr( maybeBuild(forctl->condition) ); + cond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) ); Expression *incr = 0; if ( forctl->change != 0 ) - incr = maybeBuild(forctl->change); + incr = maybeMoveBuild< Expression >(forctl->change); delete forctl; @@ -142,42 +142,43 @@ } Statement *build_computedgoto( ExpressionNode *ctl ) { - return new BranchStmt( noLabels, maybeBuild(ctl), BranchStmt::Goto ); + return new BranchStmt( noLabels, maybeMoveBuild< Expression >(ctl), BranchStmt::Goto ); } Statement *build_return( ExpressionNode *ctl ) { - std::list exps; - buildList( ctl, exps ); + std::list< Expression * > exps; + buildMoveList( ctl, exps ); return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr ); } Statement *build_throw( ExpressionNode *ctl ) { - std::list exps; - buildList( ctl, exps ); - return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr, true ); + std::list< Expression * > exps; + buildMoveList( ctl, exps ); + assertf( exps.size() < 2, "This means we are leaking memory"); + return new ReturnStmt( noLabels, !exps.empty() ? exps.back() : nullptr, true ); } Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) { - std::list branches; - buildList( catch_stmt, branches ); - CompoundStmt *tryBlock = dynamic_cast(maybeBuild(try_stmt)); + std::list< Statement * > branches; + buildMoveList< Statement, StatementNode >( catch_stmt, branches ); + CompoundStmt *tryBlock = dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt)); assert( tryBlock ); - FinallyStmt *finallyBlock = dynamic_cast(maybeBuild(finally_stmt) ); + FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) ); return new TryStmt( noLabels, tryBlock, branches, finallyBlock ); } Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny ) { - std::list branches; - buildList( stmt, branches ); - assert( branches.size() == 1 ); - return new CatchStmt( noLabels, maybeBuild(decl), branches.front(), catchAny ); + std::list< Statement * > branches; + buildMoveList< Statement, StatementNode >( stmt, branches ); + assert( branches.size() == 1 ); + return new CatchStmt( noLabels, maybeMoveBuild< Declaration >(decl), branches.front(), catchAny ); } Statement *build_finally( StatementNode *stmt ) { - std::list branches; - buildList( stmt, branches ); - assert( branches.size() == 1 ); - return new FinallyStmt( noLabels, dynamic_cast( branches.front() ) ); + std::list< Statement * > branches; + buildMoveList< Statement, StatementNode >( stmt, branches ); + assert( branches.size() == 1 ); + return new FinallyStmt( noLabels, dynamic_cast< CompoundStmt * >( branches.front() ) ); } Statement *build_compound( StatementNode *first ) { CompoundStmt *cs = new CompoundStmt( noLabels ); - buildList( first, cs->get_kids() ); + buildMoveList( first, cs->get_kids() ); return cs; } @@ -187,7 +188,7 @@ std::list< ConstantExpr * > clob; - buildList( output, out ); - buildList( input, in ); - buildList( clobber, clob ); + buildMoveList( output, out ); + buildMoveList( input, in ); + buildMoveList( clobber, clob ); return new AsmStmt( noLabels, voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels ); } Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 7b1bfc597c11725f68bb6b8790ca6a3501cd1bf7) +++ src/Parser/TypeData.cc (revision 4a7d895054466f290f1d971a3482f0e4ff8a3c74) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Sat Aug 13 18:38:41 2016 -// Update Count : 59 +// Last Modified On : Thu Aug 18 23:48:44 2016 +// Update Count : 64 // @@ -182,5 +182,4 @@ break; case Array: -//PAB newtype->array->dimension = maybeClone( array->dimension ); newtype->array->dimension = array->dimension; newtype->array->isVarLen = array->isVarLen; @@ -479,5 +478,5 @@ } -Declaration *TypeData::buildDecl( std::string name, DeclarationNode::StorageClass sc, Expression *bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Type linkage, Initializer *init ) const { +Declaration *TypeData::buildDecl( std::string name, DeclarationNode::StorageClass sc, Expression *bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer *init ) const { if ( kind == TypeData::Function ) { FunctionDecl *decl; @@ -489,6 +488,6 @@ decl = new FunctionDecl( name, sc, linkage, buildFunction(), body, isInline, isNoreturn ); } else { - // std::list