Changeset 7880579

Timestamp:

Aug 16, 2016, 8:59:49 AM (7 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

0da3e2c, 13e3b50, 7527e63

Parents:

b1848a0

Message:

more refactoring of parser code

Location:

src

Files:

• Parser/DeclarationNode.cc (modified) (10 diffs)
• Parser/ExpressionNode.cc (modified) (9 diffs)
• Parser/InitializerNode.cc (modified) (4 diffs)
• Parser/ParseNode.cc (modified) (3 diffs)
• Parser/ParseNode.h (modified) (14 diffs)
• Parser/Parser.cc (modified) (1 diff)
• Parser/Parser.h (modified) (1 diff)
• Parser/StatementNode.cc (modified) (7 diffs)
• Parser/TypeData.cc (modified) (4 diffs)
• Parser/TypedefTable.cc (modified) (4 diffs)
• Parser/TypedefTable.h (modified) (2 diffs)
• main.cc (modified) (3 diffs)

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // 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 : Mon Aug 15 20:48:55 2016
+// Update Count     : 178
 //
 
@@ -49 +49 @@
         newnode->name = name;
         newnode->storageClasses = storageClasses;
-//PAB   newnode->bitfieldWidth = maybeClone( bitfieldWidth );
         newnode->bitfieldWidth = bitfieldWidth;
         newnode->hasEllipsis = hasEllipsis;
         newnode->initializer = initializer;
-        newnode->next = maybeClone( next );
+        newnode->set_next( maybeClone( get_next() ) );
         newnode->linkage = linkage;
         return newnode;
@@ -284 +283 @@
         newnode->type->array->dimension = size;
         newnode->type->array->isStatic = isStatic;
-        if ( newnode->type->array->dimension == 0 || dynamic_cast<ConstantExpr *>( newnode->type->array->dimension->build() ) ) {
+        if ( newnode->type->array->dimension == 0 || dynamic_cast< ConstantExpr * >( newnode->type->array->dimension->build() ) ) {
                 newnode->type->array->isVarLen = false;
         } else {
@@ -776 +775 @@
 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 +793 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast<DeclarationNode *>( cur->get_next() );
+                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -801 +800 @@
 }
 
-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 +816 @@
                         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 +830 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode *>( cur->get_next() );
+                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -838 +837 @@
 }
 
-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 +847 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode *>( cur->get_next() );
+                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // 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 +32 @@
 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 ) {}
 
 //##############################################################################
@@ -166 +166 @@
 } // build_constantStr
 
-//##############################################################################
-
 NameExpr * build_varref( const string *name, bool labelp ) {
         return new NameExpr( *name, nullptr );
 }
-
-//##############################################################################
 
 static const char *OperName[] = {
@@ -184 +180 @@
 };
 
-//##############################################################################
-
 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<Expression>(expr_node) );
+                return new CastExpr( maybeBuild< Expression >(expr_node) );
         } else {
-                return new CastExpr( maybeBuild<Expression>(expr_node), targetType );
+                return new CastExpr( maybeBuild< Expression >(expr_node), targetType );
         } // if
 }
 
 Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member ) {
-        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeBuild<Expression>(expr_node) );
+        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeBuild< Expression >(expr_node) );
         delete member;
         return ret;
@@ -204 +198 @@
 Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member ) {
         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-        deref->get_args().push_back( maybeBuild<Expression>(expr_node) );
+        deref->get_args().push_back( maybeBuild< Expression >(expr_node) );
         UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
         delete member;
@@ -211 +205 @@
 
 Expression *build_addressOf( ExpressionNode *expr_node ) {
-                return new AddressExpr( maybeBuild<Expression>(expr_node) );
+                return new AddressExpr( maybeBuild< Expression >(expr_node) );
 }
 Expression *build_sizeOfexpr( ExpressionNode *expr_node ) {
-        return new SizeofExpr( maybeBuild<Expression>(expr_node) );
+        return new SizeofExpr( maybeBuild< Expression >(expr_node) );
 }
 Expression *build_sizeOftype( DeclarationNode *decl_node ) {
@@ -220 +214 @@
 }
 Expression *build_alignOfexpr( ExpressionNode *expr_node ) {
-        return new AlignofExpr( maybeBuild<Expression>(expr_node) );
+        return new AlignofExpr( maybeBuild< Expression >(expr_node) );
 }
 Expression *build_alignOftype( DeclarationNode *decl_node ) {
@@ -230 +224 @@
 
 Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind ) {
-        return new LogicalExpr( notZeroExpr( maybeBuild<Expression>(expr_node1) ), notZeroExpr( maybeBuild<Expression>(expr_node2) ), kind );
+        return new LogicalExpr( notZeroExpr( maybeBuild< Expression >(expr_node1) ), notZeroExpr( maybeBuild< Expression >(expr_node2) ), kind );
 }
 
 Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node ) {
-        std::list<Expression *> args;
-        args.push_back( maybeBuild<Expression>(expr_node) );
+        std::list< Expression * > args;
+        args.push_back( maybeBuild< Expression >(expr_node) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ) {
-        std::list<Expression *> args;
-        args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node) ) );
+        std::list< Expression * > args;
+        args.push_back( new AddressExpr( maybeBuild< 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<Expression *> args;
-        args.push_back( maybeBuild<Expression>(expr_node1) );
-        args.push_back( maybeBuild<Expression>(expr_node2) );
+        std::list< Expression * > args;
+        args.push_back( maybeBuild< Expression >(expr_node1) );
+        args.push_back( maybeBuild< 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<Expression *> args;
-        args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node1) ) );
-        args.push_back( maybeBuild<Expression>(expr_node2) );
+        std::list< Expression * > args;
+        args.push_back( new AddressExpr( maybeBuild< Expression >(expr_node1) ) );
+        args.push_back( maybeBuild< 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<Expression>(expr_node1) ), maybeBuild<Expression>(expr_node2), maybeBuild<Expression>(expr_node3) );
+        return new ConditionalExpr( notZeroExpr( maybeBuild< Expression >(expr_node1) ), maybeBuild< Expression >(expr_node2), maybeBuild< Expression >(expr_node3) );
 }
 
 Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
-        return new CommaExpr( maybeBuild<Expression>(expr_node1), maybeBuild<Expression>(expr_node2) );
+        return new CommaExpr( maybeBuild< Expression >(expr_node1), maybeBuild< Expression >(expr_node2) );
 }
 
 Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node ) {
-        return new AttrExpr( var, maybeBuild<Expression>(expr_node) );
+        return new AttrExpr( var, maybeBuild< Expression >(expr_node) );
 }
 Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node ) {
@@ -278 +272 @@
 
 Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
-        std::list<Expression *> args;
+        std::list< Expression * > args;
 
         buildList( expr_node, args );
-        return new UntypedExpr( maybeBuild<Expression>(function), args, nullptr );
+        return new UntypedExpr( maybeBuild< Expression >(function), args, nullptr );
 }
 
 Expression *build_range( ExpressionNode * low, ExpressionNode *high ) {
-        Expression *low_cexpr = maybeBuild<Expression>( low );
-        Expression *high_cexpr = maybeBuild<Expression>( high );
+        Expression *low_cexpr = maybeBuild< Expression >( low );
+        Expression *high_cexpr = maybeBuild< Expression >( high );
         return new RangeExpr( low_cexpr, high_cexpr );
 }
 
-//##############################################################################
-
 Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand ) {
-        return new AsmExpr( maybeBuild< Expression >( inout ), constraint, maybeBuild<Expression>(operand) );
-}
-
-//##############################################################################
-
-//void LabelNode::print( std::ostream &os, int indent ) const {}
-
-//void LabelNode::printOneLine( std::ostream &os, int indent ) const {}
-
-//##############################################################################
+        return new AsmExpr( maybeBuild< Expression >( inout ), constraint, maybeBuild< Expression >(operand) );
+}
 
 Expression *build_valexpr( StatementNode *s ) {
-        return new UntypedValofExpr( maybeBuild<Statement>(s), nullptr );
-}
-
-//##############################################################################
-
+        return new UntypedValofExpr( maybeBuild< Statement >(s), nullptr );
+}
 Expression *build_typevalue( DeclarationNode *decl ) {
         return new TypeExpr( decl->buildType() );
 }
 
-//##############################################################################
-
 Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids ) {
-        Declaration * newDecl = maybeBuild<Declaration>(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<Initializer>(kids) );
+                return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeBuild< 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<Initializer>(kids) );
+                return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeBuild< Initializer >(kids) );
         } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
-                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeBuild<Initializer>(kids) );
+                return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeBuild< Initializer >(kids) );
         } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
-                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeBuild<Initializer>(kids) );
+                return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeBuild< Initializer >(kids) );
         } else {
                 assert( false );

src/Parser/InitializerNode.cc

@@ -10 +10 @@
 // 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 +25 @@
         : 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 +37 @@
 
         if ( aggrp )
-                kids = dynamic_cast< InitializerNode *>( get_next() );
+                kids = dynamic_cast< InitializerNode * >( get_next() );
 
         if ( kids != 0 )
@@ -82 +82 @@
                 //assert( next_init() != 0 );
 
-                std::list< Initializer *> initlist;
-                buildList<Initializer, InitializerNode>( next_init(), initlist );
+                std::list< Initializer * > initlist;
+                buildList< Initializer, InitializerNode >( next_init(), initlist );
 
-                std::list< Expression *> designlist;
+                std::list< Expression * > designlist;
 
                 if ( designator != 0 ) {
-                        buildList<Expression, ExpressionNode>( 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<Expression, ExpressionNode>( designator, designators );
+                        buildList< Expression, ExpressionNode >( designator, designators );
 
                 if ( get_expression() != 0)
-                        return new SingleInit( maybeBuild<Expression>( get_expression() ), designators, maybeConstructed );
+                        return new SingleInit( maybeBuild< Expression >( get_expression() ), designators, maybeConstructed );
         } // if
 

src/Parser/ParseNode.cc

@@ -10 +10 @@
 // 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 : Tue Aug 16 08:42:29 2016
+// Update Count     : 107
 // 
 
@@ -17 +17 @@
 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() : next( nullptr ) {};
+ParseNode::ParseNode( const string *name ) : name( *name ), next( nullptr ) { delete name; }
+ParseNode::ParseNode( const string &name ) : name( name ), next( nullptr ) { }
 
 ParseNode::~ParseNode() {
@@ -41 +40 @@
 }
 
-void ParseNode::print( std::ostream &os, int indent ) const {}
-
-
 void ParseNode::printList( std::ostream &os, int indent ) const {
         print( os, indent );

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 Aug 15 14:52:12 2016
-// Update Count     : 512
+// Last Modified On : Tue Aug 16 08:37:47 2016
+// Update Count     : 527
 //
 
@@ -22 +22 @@
 #include <memory>
 
-#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 +36 @@
 class InitializerNode;
 
-// Builder
+//##############################################################################
+
 class ParseNode {
   public:
@@ -44 +44 @@
         ParseNode( const std::string & );                                       // for copy constructing subclasses
         virtual ~ParseNode();
+        virtual ParseNode *clone() const { assert( false ); return nullptr; };
 
         ParseNode *get_next() const { return next; }
@@ -50 +51 @@
         ParseNode *set_last( ParseNode * );
 
-        virtual ParseNode *clone() const { return 0; };
-
         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 print( std::ostream &os, int indent = 0 ) const {}
         virtual void printList( std::ostream &os, int indent = 0 ) const;
-
-        ParseNode &operator,( ParseNode & );
-  protected:
+  private:
+        static int indent_by;
+
+        ParseNode *next;
         std::string name;
-        static int indent_by;
-        ParseNode *next;
-};
+}; // ParseNode
 
 //##############################################################################
@@ -104 +102 @@
         virtual ~ExpressionNode() {}
 
-        virtual ExpressionNode *clone() const { return 0; }
+        virtual ExpressionNode *clone() const { assert( false ); return nullptr; }
 
         bool get_extension() const { return extension; }
@@ -119 +117 @@
 
 template< typename T >
-struct maybeBuild_t<Expression, T> {
+struct maybeBuild_t< Expression, T > {
         static inline Expression * doit( const T *orig ) {
                 if ( orig ) {
@@ -126 +124 @@
                         return p;
                 } else {
-                        return 0;
+                        return nullptr;
                 } // if
         }
@@ -228 +226 @@
         static DeclarationNode *newBuiltinType( BuiltinType );
 
+        DeclarationNode();
+        ~DeclarationNode();
+        DeclarationNode *clone() const;
+
         DeclarationNode *addQualifiers( DeclarationNode *);
         DeclarationNode *copyStorageClasses( DeclarationNode *);
@@ -254 +256 @@
         DeclarationNode *appendList( DeclarationNode * );
 
-        DeclarationNode *clone() const;
         void print( std::ostream &os, int indent = 0 ) const;
         void printList( std::ostream &os, int indent = 0 ) const;
@@ -269 +270 @@
         bool get_extension() const { return extension; }
         DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
-
-        DeclarationNode();
-        ~DeclarationNode();
   private:
         StorageClass buildStorageClass() const;
@@ -351 +349 @@
 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<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 ) );
+//                      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 +363 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< NodeType *>( cur->get_next() );
+                cur = dynamic_cast< NodeType * >( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -374 +372 @@
 // 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 );
 

src/Parser/Parser.cc

@@ -10 +10 @@
 // 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
+// Last Modified On : Mon Aug 15 17:44:22 2016
+// Update Count     : 7
 // 
 

src/Parser/Parser.h

@@ -10 +10 @@
 // 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
+// Last Modified On : Mon Aug 15 16:33:22 2016
+// Update Count     : 3
 //
 

src/Parser/StatementNode.cc

@@ -10 +10 @@
 // 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 +32 @@
                 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<DeclarationNode *>(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<DeclarationNode *>( 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<Declaration>(agg) );
+                stmt = new DeclStmt( noLabels, maybeBuild< Declaration >(agg) );
         } else {
                 assert( false );
@@ -54 +54 @@
         // find end of list and maintain previous pointer
         for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
-                StatementNode *node = dynamic_cast<StatementNode *>(curr);
+                StatementNode *node = dynamic_cast< StatementNode * >(curr);
                 assert( node );
-                assert( dynamic_cast<CaseStmt *>(node->stmt) );
+                assert( dynamic_cast< CaseStmt * >(node->stmt) );
                 prev = curr;
         } // for
         // convert from StatementNode list to Statement list
-        StatementNode *node = dynamic_cast<StatementNode *>(prev);
-        std::list<Statement *> stmts;
+        StatementNode *node = dynamic_cast< StatementNode * >(prev);
+        std::list< Statement * > stmts;
         buildList( stmt, stmts );
         // splice any new Statements to end of current Statements
-        CaseStmt * caseStmt = dynamic_cast<CaseStmt *>(node->stmt);
+        CaseStmt * caseStmt = dynamic_cast< CaseStmt * >(node->stmt);
         caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts );
         return this;
@@ -80 +80 @@
 Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt ) {
         Statement *thenb, *elseb = 0;
-        std::list<Statement *> branches;
-        buildList<Statement, StatementNode>( then_stmt, branches );
+        std::list< Statement * > branches;
+        buildList< Statement, StatementNode >( then_stmt, branches );
         assert( branches.size() == 1 );
         thenb = branches.front();
 
         if ( else_stmt ) {
-                std::list<Statement *> branches;
-                buildList<Statement, StatementNode>( else_stmt, branches );
+                std::list< Statement * > branches;
+                buildList< Statement, StatementNode >( else_stmt, branches );
                 assert( branches.size() == 1 );
                 elseb = branches.front();
         } // if
-        return new IfStmt( noLabels, notZeroExpr( maybeBuild<Expression>(ctl) ), thenb, elseb );
+        return new IfStmt( noLabels, notZeroExpr( maybeBuild< Expression >(ctl) ), thenb, elseb );
 }
 
 Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt ) {
-        std::list<Statement *> branches;
-        buildList<Statement, StatementNode>( stmt, branches );
+        std::list< Statement * > branches;
+        buildList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() >= 0 );                                         // size == 0 for switch (...) {}, i.e., no declaration or statements
-        return new SwitchStmt( noLabels, maybeBuild<Expression>(ctl), branches );
+        return new SwitchStmt( noLabels, maybeBuild< Expression >(ctl), branches );
 }
 Statement *build_case( ExpressionNode *ctl ) {
-        std::list<Statement *> branches;
-        return new CaseStmt( noLabels, maybeBuild<Expression>(ctl), branches );
+        std::list< Statement * > branches;
+        return new CaseStmt( noLabels, maybeBuild< Expression >(ctl), branches );
 }
 Statement *build_default() {
-        std::list<Statement *> branches;
+        std::list< Statement * > branches;
         return new CaseStmt( noLabels, nullptr, branches, true );
 }
 
 Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind ) {
-        std::list<Statement *> branches;
-        buildList<Statement, StatementNode>( stmt, branches );
+        std::list< Statement * > branches;
+        buildList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
-        return new WhileStmt( noLabels, notZeroExpr( maybeBuild<Expression>(ctl) ), branches.front(), kind );
+        return new WhileStmt( noLabels, notZeroExpr( maybeBuild< Expression >(ctl) ), branches.front(), kind );
 }
 
 Statement *build_for( ForCtl *forctl, StatementNode *stmt ) {
-        std::list<Statement *> branches;
-        buildList<Statement, StatementNode>( stmt, branches );
+        std::list< Statement * > branches;
+        buildList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
 
-        std::list<Statement *> init;
+        std::list< Statement * > init;
         if ( forctl->init != 0 ) {
                 buildList( forctl->init, init );
@@ -128 +128 @@
         Expression *cond = 0;
         if ( forctl->condition != 0 )
-                cond = notZeroExpr( maybeBuild<Expression>(forctl->condition) );
+                cond = notZeroExpr( maybeBuild< Expression >(forctl->condition) );
 
         Expression *incr = 0;
         if ( forctl->change != 0 )
-                incr = maybeBuild<Expression>(forctl->change);
+                incr = maybeBuild< Expression >(forctl->change);
 
         delete forctl;
@@ -142 +142 @@
 }
 Statement *build_computedgoto( ExpressionNode *ctl ) {
-        return new BranchStmt( noLabels, maybeBuild<Expression>(ctl), BranchStmt::Goto );
+        return new BranchStmt( noLabels, maybeBuild< Expression >(ctl), BranchStmt::Goto );
 }
 
 Statement *build_return( ExpressionNode *ctl ) {
-        std::list<Expression *> exps;
+        std::list< Expression * > exps;
         buildList( ctl, exps );
         return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr );
 }
 Statement *build_throw( ExpressionNode *ctl ) {
-        std::list<Expression *> exps;
+        std::list< Expression * > exps;
         buildList( ctl, exps );
         return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr, true );
@@ -157 +157 @@
 
 Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) {
-        std::list<Statement *> branches;
-        buildList<Statement, StatementNode>( catch_stmt, branches );
-        CompoundStmt *tryBlock = dynamic_cast<CompoundStmt *>(maybeBuild<Statement>(try_stmt));
+        std::list< Statement * > branches;
+        buildList< Statement, StatementNode >( catch_stmt, branches );
+        CompoundStmt *tryBlock = dynamic_cast< CompoundStmt * >(maybeBuild< Statement >(try_stmt));
         assert( tryBlock );
-        FinallyStmt *finallyBlock = dynamic_cast<FinallyStmt *>(maybeBuild<Statement>(finally_stmt) );
+        FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeBuild< Statement >(finally_stmt) );
         return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
 }
 Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny ) {
-        std::list<Statement *> branches;
-        buildList<Statement, StatementNode>( stmt, branches );
+        std::list< Statement * > branches;
+        buildList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
-        return new CatchStmt( noLabels, maybeBuild<Declaration>(decl), branches.front(), catchAny );
+        return new CatchStmt( noLabels, maybeBuild< Declaration >(decl), branches.front(), catchAny );
 }
 Statement *build_finally( StatementNode *stmt ) {
-        std::list<Statement *> branches;
-        buildList<Statement, StatementNode>( stmt, branches );
+        std::list< Statement * > branches;
+        buildList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
-        return new FinallyStmt( noLabels, dynamic_cast<CompoundStmt *>( branches.front() ) );
+        return new FinallyStmt( noLabels, dynamic_cast< CompoundStmt * >( branches.front() ) );
 }
 

src/Parser/TypeData.cc

@@ -10 +10 @@
 // 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 : Mon Aug 15 20:48:52 2016
+// Update Count     : 62
 //
 
@@ -182 +182 @@
                 break;
           case Array:
-//PAB           newtype->array->dimension = maybeClone( array->dimension );
                 newtype->array->dimension = array->dimension;
                 newtype->array->isVarLen = array->isVarLen;
@@ -489 +488 @@
                                 decl = new FunctionDecl( name, sc, linkage, buildFunction(), body, isInline, isNoreturn );
                         } else {
-                                // std::list<Label> ls;
-                                decl = new FunctionDecl( name, sc, linkage, buildFunction(), new CompoundStmt( std::list<Label>() ), isInline, isNoreturn );
+                                // std::list< Label > ls;
+                                decl = new FunctionDecl( name, sc, linkage, buildFunction(), new CompoundStmt( std::list< Label >() ), isInline, isNoreturn );
                         } // if
                 } else {
@@ -909 +908 @@
         buildList( enumeration->constants, ret->get_members() );
         std::list< Declaration * >::iterator members = ret->get_members().begin();
-        for ( const DeclarationNode *cur = enumeration->constants; cur != NULL; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ), ++members ) {
+        for ( const DeclarationNode *cur = enumeration->constants; cur != NULL; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
                 if ( cur->get_enumeratorValue() != NULL ) {
-                        ObjectDecl *member = dynamic_cast<ObjectDecl *>(*members);
+                        ObjectDecl *member = dynamic_cast< ObjectDecl * >(*members);
                         member->set_init( new SingleInit( maybeBuild< Expression >( cur->get_enumeratorValue() ), std::list< Expression * >() ) );
                 } // if

src/Parser/TypedefTable.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:20:13 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr 13 16:57:30 2016
-// Update Count     : 24
+// Last Modified On : Mon Aug 15 18:24:42 2016
+// Update Count     : 25
 //
 
@@ -64 +64 @@
                 tableType::iterator curPos = table.find( identifier );
                 if ( curPos == table.end()) {
-                        list<Entry> newList;
+                        list< Entry > newList;
                         newList.push_front( newEntry );
                         table[identifier] = newList;
                 } else {
-                        list<Entry>::iterator listPos = (*curPos ).second.begin();
+                        list< Entry >::iterator listPos = (*curPos ).second.begin();
                         while ( listPos != (*curPos ).second.end() && listPos->scope > scope ) {
                                 listPos++;
@@ -127 +127 @@
         debugPrint( "Leaving scope " << currentScope << endl );
         for ( tableType::iterator i = table.begin(); i != table.end(); ) {
-                list<Entry> &declList = (*i).second;
+                list< Entry > &declList = (*i).second;
                 while ( ! declList.empty() && declList.front().scope == currentScope ) {
                         declList.pop_front();
@@ -157 +157 @@
         for ( tableType::const_iterator i = table.begin(); i != table.end(); i++) {
                 debugPrint( (*i ).first << ": " );
-                list<Entry> declList = (*i).second;
-                for ( list<Entry>::const_iterator j = declList.begin(); j != declList.end(); j++ ) {
+                list< Entry > declList = (*i).second;
+                for ( list< Entry >::const_iterator j = declList.begin(); j != declList.end(); j++ ) {
                         debugPrint( "(" << (*j).scope << " " << (*j).kind << ") " );
                 }

src/Parser/TypedefTable.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:24:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr 13 16:59:56 2016
-// Update Count     : 27
+// Last Modified On : Mon Aug 15 18:25:04 2016
+// Update Count     : 28
 //
 
@@ -39 +39 @@
         };
 
-        typedef std::map<std::string, std::list<Entry> > tableType;
+        typedef std::map< std::string, std::list< Entry > > tableType;
         tableType table;
 

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug  6 16:17:41 2016
-// Update Count     : 210
+// Last Modified On : Mon Aug 15 17:58:57 2016
+// Update Count     : 220
 //
 
 #include <iostream>
 #include <fstream>
-#include <cstdlib>
-#include <cstdio>
 #include <getopt.h>
 #include "Parser/Parser.h"
-#include "Parser/ParseNode.h"
-#include "Parser/LinkageSpec.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Visitor.h"
@@ -43 +39 @@
 #include "InitTweak/GenInit.h"
 #include "InitTweak/FixInit.h"
-//#include "Explain/GenProlog.h"
-//#include "Try/Visit.h"
 
 #include "Common/SemanticError.h"
@@ -384 +378 @@
         std::list< Declaration * > decls;
         if ( noprotop ) {
-                filter( translationUnit.begin(), translationUnit.end(),
-                                std::back_inserter( decls ), notPrelude );
+                filter( translationUnit.begin(), translationUnit.end(), std::back_inserter( decls ), notPrelude );
         } else {
                 decls = translationUnit;